Calculer de nouvelles couleurs

Léa veut éclaircir une photo pour ses amis. Son premier réflexe, hérité des listes : changer directement les composantes de chaque pixel. Voyons ce que Python en pense lorsque le pixel est un tuple.

On ne peut pas modifier un élément d'un tuple

Avec une liste, on peut remplacer un élément. Voyons ce qui se passe si l'on fait la même chose avec un tuple :

couleurs = [12, 200, 45]
couleurs[0] = 100
print(couleurs)

pixel = (12, 200, 45)
pixel[0] = 100
print(pixel)

Affichage :

[100, 200, 45]
TypeError: 'tuple' object does not support item assignment

La première partie fonctionne. La seconde provoque une erreur TypeError : Python refuse de modifier un élément d'un tuple. De même, les méthodes qui modifient une liste, comme append, n'existent pas pour les tuples.

Réaffecter un nom n'est pas modifier un tuple

Attention à ne pas tout mélanger : le mot « modifier » recouvre deux opérations différentes. L'instruction suivante, par exemple, est parfaitement permise :

pixel = (12, 200, 45)
pixel = (62, 250, 95)
print(pixel)

Affichage :

(62, 250, 95)

Ici, aucun tuple n'a été modifié : on a réaffecté le nom pixel, qui désigne désormais un autre tuple. Le tableau suivant résume les opérations possibles :

OpérationExempleListeTuple
Réaffecter le nomx = …ouioui
Modifier un élémentx[0] = 100ouinon (TypeError)
Ajouter un élémentx.append(255)ouinon (AttributeError)
À retenir

Le contenu d'un tuple ne peut pas être modifié : on ne peut ni remplacer, ni ajouter, ni supprimer un de ses éléments. On dit que le tuple est immuable ; une liste, dont le contenu peut être modifié, est dite mutable. En revanche, on peut toujours réaffecter le nom qui désigne un tuple.

À faire vous-même

Exercice 3.1. Le programme contient quelques lignes en commentaire. Pour chacune, prévoyez si elle fonctionne ou provoque une erreur (et laquelle), puis décommentez-la seule et exécutez pour vérifier.

Correction
InstructionRésultat
print(pixel[3])Erreur IndexError : il n'y a que les indices 0, 1 et 2.
pixel[0] = 100Erreur TypeError : on ne peut pas modifier un élément d'un tuple.
couleurs[0] = 100 puis print(couleurs)Fonctionne : affiche [100, 200, 45].
pixel = pixel[0], pixel[1], pixel[2], 255 puis print(pixel)Fonctionne : affiche (12, 200, 45, 255). Aucun tuple n'est modifié : un nouveau tuple est construit, puis le nom pixel est réaffecté à ce nouveau tuple.
pixel.append(255)Erreur AttributeError : les tuples n'ont pas de méthode append.

Calculer un nouveau tuple

Pour obtenir un pixel plus clair, Léa ne peut donc pas modifier les composantes de son pixel : elle calcule une nouvelle couleur, c'est-à-dire qu'elle construit un nouveau tuple à partir de l'ancien.

pixel = (12, 200, 45)
eclairci = (pixel[0] + 50, pixel[1] + 50, pixel[2] + 50)
print(pixel)
print(eclairci)

Affichage :

(12, 200, 45)
(62, 250, 95)
Remarque

Comme nous l'avons vu à la page précédente, les parenthèses sont facultatives. Ici, il n'y a aucune ambiguïté (ce sont les virgules qui font du résultat un tuple) : on peut donc les omettre pour alléger l'écriture.

eclairci = pixel[0] + 50, pixel[1] + 50, pixel[2] + 50

Si Léa n'a plus besoin de l'ancienne couleur, elle peut réaffecter le même nom : pixel = (pixel[0] + 50, pixel[1] + 50, pixel[2] + 50). Le nouveau tuple est d'abord calculé, puis le nom pixel le désigne.

Attention !

Si une composante dépasse 255, le résultat n'est plus une couleur valide : c'est le cas ici du vert, qui passerait à 300 avec une augmentation de 100. Nous verrons à la page 5 comment éviter ce problème avec la fonction min.

Récupérer les éléments d'un tuple dans des variables

Écrire pixel[0], pixel[1], pixel[2] devient vite pénible. Python permet d'associer en une seule instruction chaque élément d'un tuple à un nom :

pixel = (12, 200, 45)
r, g, b = pixel
print(r)
print(g)
print(b)

Affichage :

12
200
45

Cette affectation multiple « déballe » le tuple : le premier élément est associé à r, le deuxième à g, le troisième à b.

Attention !

Il faut exactement autant de noms à gauche que d'éléments dans le tuple. Sinon, Python signale une erreur ValueError : r, g = pixel échoue, car pixel contient trois éléments.

Créer un nouveau tuple à partir des éléments

Léa veut maintenant ajouter à son pixel un canal alpha, qui décrit la transparence (de 0, transparent, à 255, opaque). Le pixel a alors quatre composantes : c'est un quadruplet. Elle récupère les trois composantes, puis écrit un nouveau tuple de quatre éléments :

pixel = (12, 200, 45)
r, g, b = pixel
alpha = 128
pixel_alpha = r, g, b, alpha
print(pixel)
print(pixel_alpha)

Affichage :

(12, 200, 45)
(12, 200, 45, 128)

La ligne pixel_alpha = r, g, b, alpha crée un nouveau tuple, de quatre éléments. Le tuple pixel, lui, n'a pas été modifié : il contient toujours trois éléments. On n'a pas « ajouté » un élément à pixel, on a construit une autre valeur.

À faire vous-même

Exercice 3.2. Léa possède le pixel pixel = (200, 100, 50). Après avoir récupéré ses composantes dans r, g et b, construisez :

  1. pixel_opaque : le pixel suivi d'un canal alpha de valeur 255 ;
  2. negatif : le tuple (255 - r, 255 - g, 255 - b) ;
  3. gris : le pixel gris de même luminosité, dont les trois composantes valent la moyenne entière (r + g + b) // 3.
Correction
pixel = (200, 100, 50)

r, g, b = pixel

pixel_opaque = r, g, b, 255
negatif = 255 - r, 255 - g, 255 - b
moyenne = (r + g + b) // 3
gris = moyenne, moyenne, moyenne

print(pixel_opaque)   # (200, 100, 50, 255)
print(negatif)        # (55, 155, 205)
print(gris)           # (116, 116, 116)

Chaque ligne crée un nouveau tuple à partir des composantes r, g et b ; le tuple pixel n'est jamais modifié.

Un piège : le tuple qui contient une liste

L'immuabilité concerne les éléments du tuple eux-mêmes, pas ce que ces éléments contiennent. Si un élément est une liste, la liste peut, elle, être modifiée :

photo = ("phare.jpg", [4000, 3000])
photo[1].append("RAW")
print(photo)

Affichage :

('phare.jpg', [4000, 3000, 'RAW'])
Attention !

Le tuple contient toujours la même liste, mais le contenu de cette liste, lui, a été modifié. C'est pourquoi on place en général dans un tuple des nombres, des chaînes de caractères ou d'autres tuples, plutôt que des listes.

À retenir
  • On ne peut pas modifier un élément d'un tuple : t[i] = valeur provoque une TypeError. Le tuple est immuable.
  • On peut toujours réaffecter le nom qui désigne un tuple : t = ….
  • L'affectation multiple r, g, b = pixel associe chaque élément du tuple à un nom ; il faut autant de noms que d'éléments.
  • Pour transformer un tuple, on calcule un nouveau tuple à partir de ses éléments (pixel_alpha = r, g, b, alpha), puis on l'associe à un nom, éventuellement le même.

Léa a maintenant de quoi éclaircir un pixel. Mais une photo en contient des millions… Il faut apprendre à les passer en revue un par un : c'est le sujet de la page suivante.