Transformer toutes les valeurs d'un coup
Pour éclaircir un pixel, Léa a pris l'habitude de récupérer ses composantes puis d'écrire le nouveau tuple :
pixel = (12, 200, 45)
r, g, b = pixel
eclairci = r + 50, g + 50, b + 50
print(eclairci)
Affichage :
(62, 250, 95)
Avec trois composantes, c'est simple et lisible. Mais Léa a maintenant calculé les luminosités de toute une ligne de pixels, rangées dans un tuple de huit valeurs :
luminosites = (20, 240, 130, 200, 0, 75, 160, 90)
Pour ajouter 50 à chacune, il faudrait écrire huit noms dans une affectation multiple, ou huit
termes luminosites[0] + 50, luminosites[1] + 50… Et sur une vraie photo,
une ligne compte des centaines de pixels ! Une boucle for ne suffit pas non plus : on ne
peut pas ajouter un élément à un tuple au fil des tours. Il nous faut une écriture qui dise
simplement : « le tuple des valeurs augmentées de 50 ».
Rappel : les listes en compréhension
Vous connaissez déjà cette écriture pour les listes : une liste en compréhension décrit chacun de ses éléments à partir des éléments d'une autre séquence.
luminosites = (20, 240, 130, 200, 0, 75, 160, 90)
plus_claires = [l + 50 for l in luminosites]
print(plus_claires)
Affichage :
[70, 290, 180, 250, 50, 125, 210, 140]
On lit : « la liste des l + 50, pour chaque l de luminosites ».
Le résultat est une liste, alors que Léa voudrait un tuple.
Construire un tuple en compréhension
Pour obtenir un tuple, on donne la même écriture à la fonction tuple, qui construit le
tuple de toutes les valeurs ainsi décrites :
luminosites = (20, 240, 130, 200, 0, 75, 160, 90)
plus_claires = tuple(l + 50 for l in luminosites)
print(plus_claires)
print(luminosites)
Affichage :
(70, 290, 180, 250, 50, 125, 210, 140)
(20, 240, 130, 200, 0, 75, 160, 90)
On lit : « le tuple des l + 50, pour chaque l de luminosites ».
Comme toujours, un nouveau tuple est créé : luminosites n'a pas été modifié.
Attention !
Il n'existe pas d'écriture « entre parenthèses » pour un tuple en compréhension. Si l'on oublie
tuple, on n'obtient pas un tuple, mais un autre type d'objet, que Python affiche ainsi :
essai = (l + 50 for l in luminosites)
print(essai)
Affichage :
<generator object <genexpr> at 0x1074fdff0>
Pour construire un tuple, il faut donc toujours écrire tuple(… for … in …).
Compréhension ou déballage ?
La compréhension est surtout utile lorsque le tuple contient beaucoup de valeurs, ou un
nombre de valeurs qu'on ne connaît pas à l'avance. Pour un tuple de deux ou trois éléments,
comme un pixel, elle n'est pas indispensable : récupérer les composantes avec
r, g, b = pixel puis écrire r + 50, g + 50, b + 50 est tout aussi
correct, et souvent plus lisible. Les deux écritures donnent le même tuple.
Des transformations variées
L'expression placée avant for peut être n'importe quel calcul sur chaque valeur. Dans
l'exemple précédent, la valeur 240 est devenue 290, ce qui dépasse 255. La fonction min
règle ce problème ; on peut aussi calculer le « négatif » de chaque valeur :
luminosites = (20, 240, 130, 200, 0, 75, 160, 90)
print(tuple(min(255, l + 50) for l in luminosites))
print(tuple(255 - l for l in luminosites))
Affichage :
(70, 255, 180, 250, 50, 125, 210, 140)
(235, 15, 125, 55, 255, 180, 95, 165)
min(255, l + 50) renvoie la plus petite des deux valeurs : l + 50 tant qu'il
ne dépasse pas 255, et 255 sinon. La même écriture s'applique sans changement à un pixel, quel que
soit son nombre de composantes, par exemple un pixel avec canal alpha :
pixel = (12, 200, 45, 128)
print(tuple(min(255, c + 50) for c in pixel))
Affichage :
(62, 250, 95, 178)
À faire vous-même
Exercice 5.1. Le programme contient un tuple de dix luminosités. Construisez en
compréhension le tuple assombries, où chaque luminosité est divisée par 2 (division
entière //).
Correction
luminosites = (12, 255, 47, 190, 3, 128, 64, 220, 99, 160)
assombries = tuple(l // 2 for l in luminosites)
print(assombries) # (6, 127, 23, 95, 1, 64, 32, 110, 49, 80)
On lit : « le tuple des l // 2, pour chaque l de luminosites ».
La division entière garantit des valeurs entières, comme doivent l'être les composantes d'un pixel.
À faire vous-même
Prévoir. Avec t = (3, 8, 5), que produit chacune des instructions suivantes ?
print([2 * x for x in t])
print(tuple(2 * x for x in t))
print((2 * x for x in t))
print(tuple(min(6, x) for x in t))
Correction
[6, 16, 10]: une liste en compréhension.(6, 16, 10): le même contenu, mais dans un tuple, grâce àtuple(…).- Ce n'est pas un tuple : Python affiche
<generator object <genexpr> at 0x…>, car il manquetuple. (3, 6, 5): chaque valeur est remplacée par la plus petite entre 6 et elle-même, donc 8 devient 6.
Sur une ligne de pixels
Les éléments parcourus peuvent eux-mêmes être des tuples. Sur une ligne de pixels, on peut ainsi extraire le tuple des composantes rouges, ou celui des luminosités :
ligne = ((255, 0, 0), (0, 255, 0), (0, 0, 255), (200, 200, 200))
print(tuple(p[0] for p in ligne))
print(tuple(sum(p) // 3 for p in ligne))
Affichage :
(255, 0, 0, 200)
(85, 85, 85, 200)
Ici, p désigne successivement chaque pixel de la ligne : p[0] est sa
composante rouge, et sum(p) // 3 la moyenne entière de ses composantes.
À faire vous-même
Exercice 5.2. Avec la ligne de cinq pixels du programme, construisez en compréhension :
- le tuple
vertsdes composantes vertes des pixels ; - le tuple
luminositesdes moyennes entières des composantes de chaque pixel ; - plus difficile : le tuple
negatifs, où chaque pixel est remplacé par son négatif.
Correction
ligne = ((10, 60, 30), (250, 240, 200), (120, 90, 150), (200, 210, 190), (0, 30, 0))
verts = tuple(p[1] for p in ligne)
luminosites = tuple(sum(p) // 3 for p in ligne)
negatifs = tuple(tuple(255 - c for c in p) for p in ligne)
print(verts) # (60, 240, 90, 210, 30)
print(luminosites) # (33, 230, 120, 200, 10)
print(negatifs) # ((245, 195, 225), (5, 15, 55), (135, 165, 105), (55, 45, 65), (255, 225, 255))
Pour negatifs, la compréhension intérieure tuple(255 - c for c in p)
construit le négatif d'un pixel p ; la compréhension extérieure l'applique à chaque
pixel de la ligne. Pour un seul pixel, on aurait aussi pu écrire
r, g, b = p puis 255 - r, 255 - g, 255 - b.
À retenir
tuple(expression for x in sequence)construit le tuple des valeurs deexpression, pour chaquexde la séquence : c'est un tuple en compréhension.- Il faut écrire
tuple(…):(… for … in …)seul ne donne pas un tuple. - Un nouveau tuple est créé ; la séquence parcourue n'est pas modifiée.
- La compréhension est surtout utile pour un tuple de nombreuses valeurs ; pour deux ou trois valeurs, le déballage
r, g, b = pixelsuivi d'un nouveau tuple convient très bien.
Léa sait maintenant transformer un tuple entier en une seule ligne. Pour organiser son logiciel, elle va regrouper ces calculs dans des fonctions… qui auront souvent plusieurs résultats à rendre. Les tuples tombent à pic !
Éditeur Python