Les listes en compréhension en Python permettent de transformer ou de filtrer des éléments d’un itérable (comme une liste, un tuple ou une chaîne de caractères) en utilisant une syntaxe réduite. Contrairement à la méthode traditionnelle qui nécessite plusieurs lignes de code avec des boucles for et éventuellement des conditions, la compréhension de liste combine ces éléments dans une structure unique.

Fonctionnement

La syntaxe générale d’une liste en compréhension suit le modèle:

[expression for élément in itérable]

Ici l’expression représente la transformation à appliquer à chaque élément extrait de l’itérable. Par exemple, pour obtenir la liste des carrés des nombres de 0 à 9, on écrira simplement:

[x**2 for x in range(10)]

Cette ligne de code remplace ce qui, dans une approche classique, nécessiterait une boucle for, une instruction append et davantage de lignes.

Conditions

Il est possible d’ajouter une condition à la fin de la compréhension pour filtrer les éléments selon un critère donné. En ajoutant un if à la suite Par exemple :

[x for x in range(10) if x % 2 == 0]

Ainsi on obtient directement les nombres pairs de 0 à 9. Ce type de filtrage permet d’effectuer à la fois une sélection et une transformation des éléments dans une même instruction.

Les doubles listes

Une “double liste en compréhension” fait généralement référence à une compréhension de liste qui contient deux boucles for imbriquées. Elle est souvent utilisée pour parcourir des structures de données en deux dimensions, comme des matrices, ou pour générer des combinaisons entre deux listes.

Par exemple, imaginons une matrice 2D représentée par une liste de listes. Si l’on souhaite aplatir cette matrice (c’est-à-dire transformer [[1, 2], [3, 4]] en [1, 2, 3, 4]), on peut utiliser une double compréhension comme ceci :

[element for ligne in matrice for element in ligne]

Ici, pour chaque ligne dans la matrice, on extrait chaque élément. L’ordre des boucles est important : la première boucle est l’itération externe, et la seconde est l’itération interne.

Les doubles compréhensions sont également utilisées pour produire le produit cartésien de deux listes. Par exemple :

[(x, y) for x in [1, 2] for y in ['a', 'b']]

Cela donne [(1, ‘a’), (1, ‘b’), (2, ‘a’), (2, ‘b’)]. On voit que pour chaque x, on génère un couple avec tous les y possibles. Cela revient à imbriquer deux boucles for, mais de manière plus concise.

Enfin, on peut combiner les doubles compréhensions avec des conditions. Par exemple :

[x*y for x in range(1, 4) for y in range(1, 4) if x != y]

Ici, on multiplie tous les couples (x, y) sauf ceux où x est égal à y. Cela montre la puissance des compréhensions de liste : on peut filtrer, transformer et parcourir des structures complexes en une seule ligne, de façon lisible et efficace.

Cependant, pour des structures trop complexes ou avec plusieurs niveaux d’imbrication, il est souvent préférable d’utiliser des boucles classiques afin de maintenir la lisibilité du code.

Les listes en compréhension

All work licensed under CC BY-NC-SA 4.0