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
  1. [6, 16, 10] : une liste en compréhension.
  2. (6, 16, 10) : le même contenu, mais dans un tuple, grâce à tuple(…).
  3. Ce n'est pas un tuple : Python affiche <generator object <genexpr> at 0x…>, car il manque tuple.
  4. (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 :

  1. le tuple verts des composantes vertes des pixels ;
  2. le tuple luminosites des moyennes entières des composantes de chaque pixel ;
  3. 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 de expression, pour chaque x de 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 = pixel suivi 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 !