Passer la photo en revue

Léa s'attaque à une première vraie tâche : mesurer la luminosité d'une photo. Il faut pour cela examiner les pixels l'un après l'autre. Elle commence par une toute petite « photo » d'une seule ligne de cinq pixels.

Parcourir les éléments d'un tuple

Comme pour une liste, la boucle for permet de parcourir un tuple élément par élément :

pixel = (200, 180, 90)
for composante in pixel:
    print(composante)

Affichage :

200
180
90

On peut aussi parcourir les indices avec range(len(t)). C'est utile quand on a besoin de la position de l'élément :

pixel = (200, 180, 90)
for i in range(len(pixel)):
    print("composante", i, ":", pixel[i])

Affichage :

composante 0 : 200
composante 1 : 180
composante 2 : 90

Les fonctions len, sum, min et max fonctionnent directement sur un tuple de nombres :

pixel = (200, 180, 90)
print(len(pixel), sum(pixel), min(pixel), max(pixel))

Affichage :

3 470 90 200

La luminosité d'un pixel peut s'estimer par la moyenne de ses trois composantes : \( \displaystyle \frac{\text{rouge} + \text{vert} + \text{bleu}}{3} \).

À faire vous-même

Exercice 4.1. Complétez la boucle pour calculer la somme des composantes du pixel, puis la moyenne.

Correction
pixel = (200, 180, 90)

somme = 0
for composante in pixel:
    somme = somme + composante

moyenne = somme / len(pixel)
print(moyenne)   # 156.66666666666666

somme est un accumulateur : initialisé à 0 avant la boucle, il augmente à chaque tour. On aurait aussi pu écrire directement sum(pixel) / len(pixel).

Les tuples de tuples

Une ligne de la photo est un tuple de pixels, et chaque pixel est lui-même un tuple de trois composantes. Un tuple peut en effet contenir d'autres tuples :

ligne = ((255, 0, 0), (0, 255, 0), (0, 0, 255))
print(ligne[1])
print(ligne[1][0])
print(len(ligne))
for pixel in ligne:
    print(pixel, "a pour somme", sum(pixel))

Affichage :

(0, 255, 0)
0
3
(255, 0, 0) a pour somme 255
(0, 255, 0) a pour somme 255
(0, 0, 255) a pour somme 255

ligne[1] est le deuxième pixel, c'est-à-dire le tuple (0, 255, 0) ; ligne[1][0] est la première composante de ce pixel (le rouge), soit 0.

À faire vous-même

Prévoir. Avec ligne = ((255, 0, 0), (0, 255, 0), (0, 0, 255)), quelle est la valeur de ligne[2][2] ? Et celle de ligne[0][1] ?

Correction

ligne[2] est le dernier pixel (0, 0, 255) ; son élément d'indice 2 est donc 255. ligne[0] est le premier pixel (255, 0, 0), dont l'élément d'indice 1 (le vert) est 0.

À faire vous-même

Exercice 4.2. Dans la ligne de cinq pixels du programme, un pixel est « clair » si la moyenne de ses composantes dépasse 127. Complétez le programme pour compter les pixels clairs.

Correction
ligne = ((10, 20, 30), (250, 240, 230), (120, 130, 140), (200, 200, 200), (0, 0, 0))

nb_clairs = 0
for pixel in ligne:
    moyenne = (pixel[0] + pixel[1] + pixel[2]) / 3
    if moyenne > 127:
        nb_clairs = nb_clairs + 1

print(nb_clairs)   # 3

Les moyennes valent 20, 240, 130, 200 et 0 : trois d'entre elles dépassent 127.

À faire vous-même

Exercice 4.3. Avec la même ligne de pixels, trouvez l'indice du pixel le plus sombre (celui dont la moyenne des composantes est la plus faible) et affichez cet indice ainsi que le pixel correspondant. Vous parcourrez les indices avec range(len(ligne)).

Correction
ligne = ((10, 20, 30), (250, 240, 230), (120, 130, 140), (200, 200, 200), (0, 0, 0))

indice_min = 0
moyenne_min = sum(ligne[0]) / 3
for i in range(len(ligne)):
    moyenne = sum(ligne[i]) / 3
    if moyenne < moyenne_min:
        moyenne_min = moyenne
        indice_min = i

print(indice_min, ligne[indice_min])   # 4 (0, 0, 0)

On initialise le minimum avec le premier pixel, puis on le remplace chaque fois qu'on trouve plus sombre. On garde l'indice i en plus de la valeur : c'est ici que le parcours par indices est utile.

À retenir
  • On parcourt un tuple comme une liste : for element in t: ou for i in range(len(t)):.
  • len, sum, min et max s'appliquent à un tuple de nombres.
  • Un tuple peut contenir des tuples : ligne[i][j] est la composante j du pixel i.
  • Pour calculer un résultat sur tout un tuple, on utilise un accumulateur (somme, compteur, minimum…) mis à jour dans la boucle.

Léa sait maintenant parcourir un tuple. Mais pour transformer toutes les valeurs d'un tuple, par exemple ajouter 50 à chacune, une boucle ne suffit pas : on ne peut pas remplir un tuple au fil des tours. La page suivante présente une écriture faite pour cela.