Exercices

Léa a posé les bases de son logiciel de retouche. Voici trois exercices pour vous entraîner : lecture de code, raisonnement sur les types, puis écriture de fonctions testées par des assert.

Conseils
  • Répondez d'abord sur papier, sans exécuter de code, pour les questions de lecture.
  • Pour les fonctions, lisez attentivement les assert : ils précisent les cas à traiter.

Exercice 1 : lecture de code

On considère la fonction et les instructions suivantes :

def f(t):
    a = t[0]
    b = t[len(t) - 1]
    return (b, a)

x = (1, 2, 3, 4)
y = f(x)
  1. Quel est le type de y ? Donner sa valeur.
  2. Quelle valeur renvoie f((5,)) ?
  3. On exécute ensuite l'instruction x[1] = 9. Que se passe-t-il ? Justifier.
  4. Écrire une instruction qui construit un tuple z contenant les mêmes éléments que x, sauf le premier qui est remplacé par 0.
Correction
  1. y est un tuple (la fonction renvoie le couple (b, a)) : y = (4, 1). La fonction renvoie le couple formé du dernier puis du premier élément.
  2. Pour t = (5,), on a t[0] et t[len(t) - 1] égaux à 5 : la fonction renvoie (5, 5).
  3. L'instruction provoque une erreur TypeError : un tuple est immuable, on ne peut pas affecter un de ses éléments.
  4. z = (0, x[1], x[2], x[3]), ce qui donne (0, 2, 3, 4). On construit un nouveau tuple en recopiant les éléments de x, sauf le premier remplacé par 0.

Exercice 2 : les images de Léa

Léa représente une image par une liste de lignes ; chaque ligne est une liste de pixels ; chaque pixel est un tuple (rouge, vert, bleu). Voici une image de 3 pixels de large et 2 de haut :

image = [[(255, 0, 0), (0, 255, 0), (0, 0, 255)],
         [(255, 255, 255), (0, 0, 0), (128, 128, 128)]]
  1. Combien de lignes contient cette image ? Combien de pixels contient chaque ligne ?
  2. Donner la valeur de image[1][2] et celle de image[0][1][1].
  3. L'instruction image[0][1] = (0, 0, 0) fonctionne-t-elle ? Et l'instruction image[0][1][0] = 0 ? Justifier.
  4. Écrire la fonction dimensions(image) qui renvoie le couple (largeur, hauteur) d'une image (on suppose qu'elle contient au moins une ligne).
  5. Écrire la fonction negatif_image(image) qui renvoie une nouvelle image dont chaque composante c est remplacée par 255 - c. L'image renvoyée a la même structure : une liste de lignes, chaque ligne étant une liste de tuples.
  6. Pourquoi est-il pertinent de représenter un pixel par un tuple plutôt que par une liste ?
Correction
  1. L'image contient 2 lignes de 3 pixels chacune.
  2. image[1][2] vaut (128, 128, 128) (troisième pixel de la deuxième ligne) ; image[0][1][1] vaut 255 (composante verte du deuxième pixel de la première ligne).
  3. image[0][1] = (0, 0, 0) fonctionne : image[0] est une liste, on peut donc remplacer l'un de ses éléments (ici le deuxième pixel, par un nouveau tuple). En revanche, image[0][1][0] = 0 provoque une TypeError : image[0][1] est un tuple, et on ne peut pas modifier un élément d'un tuple.
  4. def dimensions(image):
        hauteur = len(image)
        largeur = len(image[0])
        return (largeur, hauteur)
  5. def negatif_image(image):
        resultat = []
        for ligne in image:
            nouvelle_ligne = []
            for pixel in ligne:
                rouge, vert, bleu = pixel
                nouvelle_ligne.append((255 - rouge, 255 - vert, 255 - bleu))
            resultat.append(nouvelle_ligne)
        return resultat
    Chaque nouveau pixel est un tuple calculé à partir de l'ancien ; les lignes et l'image, qui sont des collections, sont construites avec append. L'image d'origine n'est pas modifiée.
  6. Un pixel a toujours exactement trois composantes, dont la position donne le sens (rouge, vert, bleu) : c'est une valeur composée, pas une collection dont le nombre d'éléments varie. Le tuple, de taille fixe, correspond exactement à cette nature, tandis que les lignes et l'image, dont la taille dépend de la photo, sont des collections : des listes. Transformer un pixel revient alors à calculer un nouveau tuple, comme le fait negatif_image.

Exercice 3 : le pixel le plus clair

Écrire la fonction plus_clair(ligne) qui prend en paramètre un tuple non vide de pixels et renvoie le couple (indice, pixel) du pixel dont la somme des composantes est la plus grande. En cas d'égalité, on renvoie le premier. Les tests assert fournis doivent être tous vérifiés.

Correction
def plus_clair(ligne):
    indice_max = 0
    somme_max = sum(ligne[0])
    for i in range(1, len(ligne)):
        somme = sum(ligne[i])
        if somme > somme_max:
            somme_max = somme
            indice_max = i
    return (indice_max, ligne[indice_max])

On initialise avec le premier pixel, puis on parcourt les indices suivants. Le test strict > garantit qu'en cas d'égalité on garde le premier pixel rencontré. La fonction renvoie un tuple (indice, pixel), qu'on pourra déballer à l'appel : i, p = plus_clair(ligne).

À retenir

Pensez à vérifier : le type de ce que renvoie une fonction (tuple ou valeur simple ?), l'immuabilité (aucune affectation t[i] = …), les indices (de 0 à len(t) - 1) et les cas limites (tuple d'un seul élément).

Bravo : vous savez maintenant manipuler les tuples. Il est temps de les retrouver dans un cadre réel : avec la bibliothèque Pillow, Léa va enfin travailler sur ses vraies photos.