Chapitre 10: La compréhension de liste

La compréhension de liste est une expression qui permet de construire une liste à partir de tout autre type itérable (liste, tuple, chaîne de caractères…). Le résultat obtenu est toujours une liste.

python

1) Une compréhension de liste toute simple

Un exemple valant mieux qu’un long discours, nous allons créer une liste de nombres entiers :

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

À l’aide d’une boucle for et de la méthode append(), nous allons ajouter à une nouvelle liste baptisée liste_2, chaque élément de liste_initiale multiplié par deux.

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
liste_2 = []
for n in liste_initiale:
    liste_2.append(n*2)
print(liste_2)

Résultat : liste_2 = [0, 2, 4, 6, 8, 10 ,12, 14, 16, 18, 20, 22, 24, 26, 28, 30]

J’ai donc utilisé une boucle for pour écrire ce petit bout de code de cinq lignes. Mais j’aurais tout aussi bien pu utiliser une compréhension de liste pour obtenir le même résultat. Voici la syntaxe de cette dernière :

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
liste_2 = [n*2 for n in liste_initiale]
print(liste_2)

Résultat : liste_2 = [0, 2, 4, 6, 8, 10 ,12, 14, 16, 18, 20, 22, 24, 26, 28, 30]

Que remarque-t-on? Le code est plus concis puisqu’il tient sur trois lignes au lieu de cinq. Vous allez me dire que la différence est minime et dans cet exemple tout simple, je dois reconnaître que vous avez raison! Mais attendez de voir la suite…

2) Une compréhension de liste avec une condition

Je souhaite  créer une nouvelle liste de nombres pairs multipliés par 2 à partir de liste_initiale qui contient, je vous le rappelle des nombres pairs et impairs. Il va donc falloir que j’introduise une condition pour ignorer les nombres impairs. Comparons une nouvelle fois le code écrit avec une boucle for et celui écrit avec une compréhension de liste.

Avec une boucle for

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
liste_pair = []
for n in liste_initiale:
    if n % 2 == 0:
        liste_pair.append(n*2)
print(liste_pair)

Résultat : liste_pair = [0, 4, 8,  12, 16, 20, 24, 28]

Avec une compréhension de liste

J’introduis la condition à la fin de la compréhension de liste. Au lieu d’avoir six lignes de code, je n’en ai plus que trois.

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
liste_pair = [n*2 for n in liste_initiale if n % 2 == 0]
print(liste_pair)

Résultat : liste_pair = [0, 4, 8,  12, 16, 20, 24, 28]

3) Une compréhension de liste avec une expression conditionnelle

Encore plus fort, je souhaite créer une nouvelle liste avec les éléments de liste_initiale. Les chiffres pairs seront multipliés par deux, les chiffres impairs par trois. Il va donc falloir que j’introduise une condition if… else.

Avec une boucle for

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
nouvelle_liste = []
for n in liste_initiale:
    if n % 2 == 0:
        nouvelle_liste.append(n*2)
    else:
        nouvelle_liste.append(n*3)
print(nouvelle_liste)

Résultat : nouvelle_liste = [0, 3, 4, 9, 8, 15, 12, 21, 16, 27, 20, 33, 24, 39, 28, 45]

Avec une compréhension de liste

Ça se complique un peu car il faut utiliser une expression conditionnelle qui évalue si la condition est vraie (True) ou fausse (False). Mais le résultat est au rendez-vous puisqu’au lieu d’avoir huit lignes de code, je n’en ai que trois!

liste_initiale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
nouvelle_liste = [n*2 if n % 2 == 0 else n*3 for n in liste_initiale]
print(nouvelle_liste)

 4) Une compréhension de liste avec une liste de listes

Il est possible de faire une compréhension de liste avec une liste de listes. Pour s’y retrouver dans l’imbrication des instructions, le plus simple est de comparer la syntaxe d’une boucle for avec celle d’une compréhension de liste.

Avec une boucle for

liste_initiale = [[0, 'a'], [2, 'b'], [3, 'c']]
nouvelle_liste = []
for i in liste_initiale :
    for n in i :
        nouvelle_liste.append(n*2)
print(nouvelle_liste)

Résultat: nouvelle_liste = [0, ‘aa’, 4, ‘bb’, 6, ‘cc’]

Avec une compréhension de liste

liste_initiale = [[0, 'a'], [2, 'b'], [3, 'c']]
nouvelle_liste = [n*2 for i in liste_initiale for n in i]
print(nouvelle_liste)

Résultat: nouvelle_liste = [0, ‘aa’, 4, ‘bb’, 6, ‘cc’]

Avec une expression conditionnelle

Par exemple, je veux multiplier les nombres entiers par deux et les strings par trois.

liste_initiale = [[0, 'a'], [2, 'b'], [3, 'c']]
nouvelle_liste = [n*2 if type(n) == int else n*3 for i in liste_initiale for n in i]
print(nouvelle_liste)

Résultat: [0, ‘aaa’, 4, ‘bbb’, 6, ‘ccc’]

Dans ce dernier exemple, si j’avais fait usage d’une boucle for, j’aurais écrit neuf lignes de code au lieu de trois!

liste_initiale = [[0, 'a'], [2, 'b'], [3, 'c']]
nouvelle_liste = []
for i in liste_initiale:
    for n in i:
        if type(n) == int:
            nouvelle_liste.append(n*2)
        else:
            nouvelle_liste.append(n*3)
print(nouvelle_liste)

Cela dit, ce n’est pas non plus le concours de celui qui écrira le plus d’instructions sur la même ligne de code. Il faut que ça reste déchiffrable.

5) Les compréhensions de liste avec les autres types itérables

Comme je le disais en introduction, les compréhensions de liste fonctionnent avec les autres types itérables mais le résultat obtenu est toujours une liste. Par exemple, avec une chaîne de caractères :

prenom = "Gustave"
liste_lettres = [lettre for lettre in prenom]
print(liste_lettres)

Résultat: [‘G’, ‘u’, ‘s’, ‘t’, ‘a’, ‘v’, ‘e’]

Conclusion

La compréhension de liste est une méthode puissante qui a remplacé les anciennes fonctions map() et filter() dont l’usage est aujourd’hui déconseillé. Bien utilisée, la compréhension de liste rend le code plus concis, plus élégant et plus facile à comprendre qu’avec les fonctions map() et filter(). Voici la page consacrée aux compréhensions de liste dans la documentation officielle du langage Python.

Il existe également une compréhension de dictionnaire et d’ensemble que nous aborderons dans le chapitre consacré à ces deux structures de données.