Exercices
Léa a posé les bases de son logiciel de retouche. Voici trois exercices pour vous entraîner : lecture de
code, raisonnement sur les types, puis écriture de fonctions testées par des assert.
Conseils
- Répondez d'abord sur papier, sans exécuter de code, pour les questions de lecture.
- Pour les fonctions, lisez attentivement les
assert: ils précisent les cas à traiter.
Exercice 1 : lecture de code
On considère la fonction et les instructions suivantes :
def f(t):
a = t[0]
b = t[len(t) - 1]
return (b, a)
x = (1, 2, 3, 4)
y = f(x)
- Quel est le type de
y? Donner sa valeur. - Quelle valeur renvoie
f((5,))? - On exécute ensuite l'instruction
x[1] = 9. Que se passe-t-il ? Justifier. - Écrire une instruction qui construit un tuple
zcontenant les mêmes éléments quex, sauf le premier qui est remplacé par0.
Correction
yest un tuple (la fonction renvoie le couple(b, a)) :y = (4, 1). La fonction renvoie le couple formé du dernier puis du premier élément.- Pour
t = (5,), on at[0]ett[len(t) - 1]égaux à 5 : la fonction renvoie(5, 5). - L'instruction provoque une erreur
TypeError: un tuple est immuable, on ne peut pas affecter un de ses éléments. z = (0, x[1], x[2], x[3]), ce qui donne(0, 2, 3, 4). On construit un nouveau tuple en recopiant les éléments dex, sauf le premier remplacé par0.
Exercice 2 : les images de Léa
Léa représente une image par une liste de lignes ; chaque ligne est une liste de
pixels ; chaque pixel est un tuple (rouge, vert, bleu). Voici une image de 3
pixels de large et 2 de haut :
image = [[(255, 0, 0), (0, 255, 0), (0, 0, 255)],
[(255, 255, 255), (0, 0, 0), (128, 128, 128)]]
- Combien de lignes contient cette image ? Combien de pixels contient chaque ligne ?
- Donner la valeur de
image[1][2]et celle deimage[0][1][1]. - L'instruction
image[0][1] = (0, 0, 0)fonctionne-t-elle ? Et l'instructionimage[0][1][0] = 0? Justifier. -
Écrire la fonction
dimensions(image)qui renvoie le couple(largeur, hauteur)d'une image (on suppose qu'elle contient au moins une ligne). -
Écrire la fonction
negatif_image(image)qui renvoie une nouvelle image dont chaque composantecest remplacée par255 - c. L'image renvoyée a la même structure : une liste de lignes, chaque ligne étant une liste de tuples. - Pourquoi est-il pertinent de représenter un pixel par un tuple plutôt que par une liste ?
Correction
- L'image contient 2 lignes de 3 pixels chacune.
image[1][2]vaut(128, 128, 128)(troisième pixel de la deuxième ligne) ;image[0][1][1]vaut255(composante verte du deuxième pixel de la première ligne).image[0][1] = (0, 0, 0)fonctionne :image[0]est une liste, on peut donc remplacer l'un de ses éléments (ici le deuxième pixel, par un nouveau tuple). En revanche,image[0][1][0] = 0provoque uneTypeError:image[0][1]est un tuple, et on ne peut pas modifier un élément d'un tuple.-
def dimensions(image): hauteur = len(image) largeur = len(image[0]) return (largeur, hauteur) -
Chaque nouveau pixel est un tuple calculé à partir de l'ancien ; les lignes et l'image, qui sont des collections, sont construites avecdef negatif_image(image): resultat = [] for ligne in image: nouvelle_ligne = [] for pixel in ligne: rouge, vert, bleu = pixel nouvelle_ligne.append((255 - rouge, 255 - vert, 255 - bleu)) resultat.append(nouvelle_ligne) return resultatappend. L'image d'origine n'est pas modifiée. - Un pixel a toujours exactement trois composantes, dont la position donne le sens (rouge, vert, bleu) : c'est une valeur composée, pas une collection dont le nombre d'éléments varie. Le tuple, de taille fixe, correspond exactement à cette nature, tandis que les lignes et l'image, dont la taille dépend de la photo, sont des collections : des listes. Transformer un pixel revient alors à calculer un nouveau tuple, comme le fait
negatif_image.
Exercice 3 : le pixel le plus clair
Écrire la fonction plus_clair(ligne) qui prend en paramètre un tuple non vide de
pixels et renvoie le couple (indice, pixel) du pixel dont la somme des composantes
est la plus grande. En cas d'égalité, on renvoie le premier. Les tests assert fournis
doivent être tous vérifiés.
Correction
def plus_clair(ligne):
indice_max = 0
somme_max = sum(ligne[0])
for i in range(1, len(ligne)):
somme = sum(ligne[i])
if somme > somme_max:
somme_max = somme
indice_max = i
return (indice_max, ligne[indice_max])
On initialise avec le premier pixel, puis on parcourt les indices suivants. Le test strict
> garantit qu'en cas d'égalité on garde le premier pixel rencontré. La fonction renvoie un
tuple (indice, pixel), qu'on pourra déballer à l'appel :
i, p = plus_clair(ligne).
À retenir
Pensez à vérifier : le type de ce que renvoie une fonction (tuple ou valeur
simple ?), l'immuabilité (aucune affectation t[i] = …), les indices
(de 0 à len(t) - 1) et les cas limites (tuple d'un seul élément).
Bravo : vous savez maintenant manipuler les tuples. Il est temps de les retrouver dans un cadre réel : avec la bibliothèque Pillow, Léa va enfin travailler sur ses vraies photos.
Éditeur Python