Plusieurs résultats d'un coup

Pour son logiciel de retouche, Léa écrit de petites fonctions. Très vite, elle se heurte à une limite : une fonction ne peut renvoyer qu'une seule chose avec return… Et pourtant, elle aimerait connaître d'un coup la composante la plus faible et la plus forte d'un pixel. La solution : renvoyer un tuple.

Une fonction qui renvoie un tuple

def min_max(pixel):
    return (min(pixel), max(pixel))

resultat = min_max((12, 200, 45))
print(resultat)
print("la plus faible :", resultat[0])
print("la plus forte :", resultat[1])

Affichage :

(12, 200)
la plus faible : 12
la plus forte : 200

La fonction renvoie un seul objet : un tuple de deux éléments. Les parenthèses sont facultatives : return mini, maxi renvoie aussi un tuple.

Déballer le résultat d'une fonction

Nous avons vu à la page 3 l'affectation multiple r, g, b = pixel, qui associe chaque élément d'un tuple à un nom. Elle s'applique directement au tuple renvoyé par une fonction : plutôt que d'utiliser resultat[0] et resultat[1], on écrit :

def min_max(pixel):
    return min(pixel), max(pixel)

plus_faible, plus_forte = min_max((12, 200, 45))
print(plus_faible)
print(plus_forte)

Affichage :

12
200

Comme pour tout tuple, il faut autant de noms à gauche que de valeurs renvoyées par la fonction.

Le déballage fonctionne aussi dans une boucle for qui parcourt des tuples de même taille :

ligne = ((255, 0, 0), (0, 255, 0), (0, 0, 255))
for rouge, vert, bleu in ligne:
    print("rouge =", rouge, "| vert =", vert, "| bleu =", bleu)

Affichage :

rouge = 255 | vert = 0 | bleu = 0
rouge = 0 | vert = 255 | bleu = 0
rouge = 0 | vert = 0 | bleu = 255
À faire vous-même

Exercice 6.1. Complétez la fonction negatif : elle reçoit un pixel et renvoie le pixel « négatif » (255 - rouge, 255 - vert, 255 - bleu).

Correction
def negatif(pixel):
    rouge, vert, bleu = pixel
    return (255 - rouge, 255 - vert, 255 - bleu)

print(negatif((12, 200, 45)))   # (243, 55, 210)
print(negatif((0, 0, 0)))       # (255, 255, 255)

La fonction reçoit un tuple en paramètre, le déballe, puis renvoie un nouveau tuple : le pixel d'origine n'est pas modifié.

Échanger deux valeurs

Le déballage offre une écriture élégante pour échanger deux valeurs, sans variable intermédiaire :

a = 1
b = 2
a, b = b, a
print(a, b)

Affichage :

2 1

Que se passe-t-il ? À droite du =, b, a construit le tuple (2, 1) ; ensuite, ce tuple est déballé dans a puis b.

À faire vous-même

Prévoir. Que valent x, y et z à la fin du programme ?

x, y, z = 1, 2, 3
x, y, z = z, x, y
Correction

À droite du =, le tuple (z, x, y) vaut (3, 1, 2). Après déballage, x vaut 3, y vaut 1 et z vaut 2.

À faire vous-même

Exercice 6.2. Léa veut analyser séparément les trois canaux de couleur d'une ligne de pixels. Écrivez la fonction separer_canaux(ligne) qui renvoie trois listes : celle des composantes rouges, celle des composantes vertes et celle des composantes bleues.

Correction
def separer_canaux(ligne):
    rouges = []
    verts = []
    bleus = []
    for pixel in ligne:
        rouge, vert, bleu = pixel
        rouges.append(rouge)
        verts.append(vert)
        bleus.append(bleu)
    return rouges, verts, bleus

ligne = ((255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255))
rouges, verts, bleus = separer_canaux(ligne)
print(rouges)   # [255, 0, 0, 255]
print(verts)    # [0, 255, 0, 255]
print(bleus)    # [0, 0, 255, 255]

Les composantes d'un même canal forment une collection qui grandit au fil du parcours : ce sont donc des listes, remplies avec append. La fonction renvoie ces trois listes regroupées dans un tuple, que l'on déballe à l'appel.

À faire vous-même

Exercice 6.3. Écrivez la fonction permuter_rouge_bleu(pixel) qui renvoie un nouveau pixel où le rouge et le bleu sont échangés (un effet « filtre » amusant). Plus difficile : écrivez permuter_ligne(ligne) qui applique cette transformation à tous les pixels d'une ligne et renvoie la liste des pixels obtenus.

Correction
def permuter_rouge_bleu(pixel):
    rouge, vert, bleu = pixel
    return (bleu, vert, rouge)

def permuter_ligne(ligne):
    resultat = []
    for pixel in ligne:
        resultat.append(permuter_rouge_bleu(pixel))
    return resultat

print(permuter_rouge_bleu((255, 128, 0)))                 # (0, 128, 255)
print(permuter_ligne(((255, 128, 0), (10, 20, 30))))      # [(0, 128, 255), (30, 20, 10)]

Chaque pixel reste un tuple (une valeur composée) ; la ligne transformée est une collection de pixels construite au fil du parcours, donc une liste.

Un pixel qui ne « déborde » pas

Reprenons l'éclaircissement de la page 3. Si l'on ajoute 50 à un pixel déjà très clair, la composante peut dépasser 255 : ce n'est plus une couleur valide. Comme à la page précédente, la fonction min règle le problème ; regroupons ce calcul dans une fonction :

def eclaircir(pixel, valeur):
    rouge, vert, bleu = pixel
    return (min(255, rouge + valeur), min(255, vert + valeur), min(255, bleu + valeur))

print(eclaircir((12, 200, 45), 50))
print(eclaircir((250, 240, 230), 50))

Affichage :

(62, 250, 95)
(255, 255, 255)

La fonction eclaircir prend un tuple en paramètre et en renvoie un nouveau : Léa calcule une nouvelle couleur à partir de l'ancienne.

À retenir
  • Une fonction renvoie plusieurs valeurs en renvoyant un tuple : return a, b.
  • Le tuple renvoyé se « déballe » avec une affectation multiple : x, y = f(...).
  • Le nombre de noms à gauche doit correspondre au nombre d'éléments du tuple.
  • L'échange de deux variables s'écrit a, b = b, a.
  • Une fonction peut recevoir un tuple en paramètre et renvoyer un nouveau tuple calculé à partir de lui.

Léa a désormais tous les outils. Avant de se lancer dans son logiciel, elle veut faire le point : quand utiliser un tuple, quand préférer une liste ? Faisons le bilan avec elle.