Comment utiliser les listes en compréhension Python ?

Que sont les listes par compréhension ? Comment s’en servir pour rendre son code plus clair et lisible ? Découvrez tout sur cette syntaxe Python !

On a déjà vu le concept de comprehension en Python qui permet de générer plusieurs types d’objets en une seule ligne, voyons maintenant comment les listes en compréhensions fonctionnent plus exactement.

Une liste en compréhension permet de créer une nouvelle liste en une seule ligne et est composée d’une boucle “for” avec ou sans condition “if”. C’est une syntaxe entourée de crochets et qui retourne une liste en fonction du résultat des différentes itérations de la boucle.

Concrètement, une liste en comprehension ressemble à ça :

ma_liste = [expression for element in liste_de_depart if condition]

Explications vidéo des compréhensions de listes en moins d’une minute :

Une liste est un type d’objet pratique et très utilisé en Python.

Pouvoir en créer en une seule ligne et élégamment avec les compréhension de liste est un vrai plus pour le langage Python.

Voyons ensemble comment les compréhensions de listes fonctionnent à l’aide de plusieurs exemple dans cet article accessible aux développeurs Python débutants !

Pourquoi utiliser la compréhension de liste ?

Avant de voir exactement comment créer une liste par compréhension en Python, on va voir pourquoi elles sont si utiles.

Disons qu’on veuille créer une nouvelle liste qui ne contient que des nombres pairs en partant d’une liste de nombres avec des nombres pairs et impairs.

En utilisant une boucle for classique, on se retrouverait avec quelque chose comme ça :

nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nombres_pairs = []

for nombre in nombres:
  if nombre % 2 == 0:
    nombres_pairs.append(nombre)

print(nombres_pairs)

Ce qui donnerait une liste nombres_pairs qui contient :

[2, 4, 6, 8, 10]

💡 Vous souhaitez en apprendre plus sur les boucles for en Python ? Alors mon article Comment utiliser la boucle for en python ? vous intéressera sûrement !

On pourrait faire exactement la même chose avec une liste en comprehension en faisant :

nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

nombres_pairs = [nombre for nombre in nombres if nombre % 2 == 0]

print(nombres_pairs)

Ce qui donnerait le même résultat que notre exemple du dessus, une liste nombres_pairs qui contient :

[2, 4, 6, 8, 10]

C’est beaucoup mieux, non ? Apprenons-en plus sur les listes en compréhension.

Comment créer une liste par compréhension Python ?

Pour créer une liste en compréhension, on met une boucle “for” avec ou sans condition “if” entre crochets. Elle retournera une nouvelle liste en fonction du résultat des différentes itérations de la boucle.

ma_liste = [expression for element in iterable if condition]

Voyons chaque élément indépendamment :

• ma_liste est la nouvelle liste crée en résultat de l’exécution de la liste par compréhension
• = est l’opérateur d’assignation
• [] sont les crochets qui entourent la liste par compréhension
• expression est ce qu’on applique à l’élément à chaque passage dans la boucle
• for est le mot clé de boucle python
• element est l’élément parcouru lors de l’itération
• in est le mot clé python pour boucler sur des itérables
• iterable est un itérable (une liste, un tuple, un dict, …) de départ sur lequel on itère
• if est le mot clé python pour définir une condition
• condition est l’expression qui renvoie une valeur “Truthy” or “Falsy”

Comment utiliser une liste par compréhension en Python ?

Voyons plusieurs exemples utiles pour voir comment les développeurs Python utilisent la syntaxe de liste par compréhension au quotidien.

Liste par comprehension avec plusieurs conditions

On peut avoir une liste par compréhension avec plusieurs conditions.

Par exemple, si on veut une liste de nombres impairs ne contenant pas les multiples de 7 ni le nombre 13, on peut avoir une liste en compréhension comme ceci :

[i for i in range(25) if i % 2 == 1 and i % 7 != 0 and i != 13]

Ce qui donnera :

[1, 3, 5, 9, 11, 15, 17, 19, 23]

Liste par comprehension dans une liste par comprehension

On peut mettre des listes par comprehension dans des listes par comprehension pour créer des matrices (tableau de tableau).

[[i for i in range(5)] for _ in range(5)]

[
  [0, 1, 2, 3, 4],
  [0, 1, 2, 3, 4],
  [0, 1, 2, 3, 4],
  [0, 1, 2, 3, 4],
  [0, 1, 2, 3, 4]
]

Utiliser lambda avec une liste par compréhension

list(map(lambda x: x ** 2, [nombre for nombre in range(1, 10)]))

Retourne tous les nombres mis au carrés de 1 à 9 compris :

[1, 4, 9, 16, 25, 36, 49, 64, 81]

Comment utiliser une liste en compréhension sur une string ?

On peut boucler sur les chaînes de caractères comme les strings sont des itérables en Python.

Il est donc possible de créer un tableau de caractères qui composent une string en Python en utilisant un liste par compréhension :

site = [lettre for lettre in "commentcoder.com"]

print(site)

Ce qui donne :

['c', 'o', 'm', 'm', 'e', 'n', 't', 'c', 'o', 'd', 'e', 'r', '.', 'c', 'o', 'm']

Cette nouvelle liste site contient donc toutes les lettres qui composent la string commentcoder.com.

On peut aussi appliquer une expression sur chaque lettre et ajouter une condition, par exemple :

site = [lettre.upper() for lettre in "commentcoder.com" if lettre != '.']

print(site)

Donnera :

['C', 'O', 'M', 'M', 'E', 'N', 'T', 'C', 'O', 'D', 'E', 'R', 'C', 'O', 'M']

La variable site contient maintenant toutes les lettres de commentcoder.com en majuscule et sans le ..