Compréhensions de listes (list comprehensions) : création concise de listes

Qu'est-ce qu'une compréhension de liste ? Principe et avantages

Une compréhension de liste (list comprehension en anglais) est une syntaxe concise en Python qui permet de créer une nouvelle liste à partir d'une séquence existante (comme une liste, un tuple, une chaîne de caractères, ou un itérable) en appliquant une expression à chaque élément de la séquence, et éventuellement en filtrant les éléments selon une condition.

Les compréhensions de listes offrent plusieurs avantages :

• Concision : Elles permettent de créer des listes en une seule ligne de code, au lieu d'utiliser une boucle `for` explicite et une instruction `append()`.
• Lisibilité : Lorsqu'elles sont utilisées de manière appropriée, les compréhensions de listes peuvent rendre le code plus lisible et plus expressif.
• Performance : Dans de nombreux cas, les compréhensions de listes sont plus rapides que les boucles `for` équivalentes, car elles sont optimisées en interne par l'interpréteur Python.

Les compréhensions de listes sont considérées comme une caractéristique "pythonique", c'est-à-dire une fonctionnalité qui tire parti de la puissance et de l'expressivité du langage Python.

Syntaxe de base : [expression for item in iterable]

La syntaxe de base d'une compréhension de liste est la suivante :

[expression for item in iterable]

• `expression` : Une expression qui est évaluée pour chaque `item` de l'`iterable`. Le résultat de cette expression est ajouté à la nouvelle liste.
• `item` : Une variable qui prend successivement la valeur de chaque élément de l'`iterable`.
• `iterable` : Une séquence (liste, tuple, chaîne de caractères, etc.) ou un itérable.

Exemple : Créer une liste des carrés des nombres de 0 à 9

carres = [x**2 for x in range(10)]
print(carres)  # Affiche [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Cette compréhension de liste est équivalente à la boucle `for` suivante :

carres = []
for x in range(10):
    carres.append(x**2)
print(carres)

Autre exemple, transformer une chaîne de caractères en liste de caractères :

message = "Bonjour"
lettres = [lettre for lettre in message]
print(lettres) # Affiche ['B', 'o', 'n', 'j', 'o', 'u', 'r']

Ajouter une condition : [expression for item in iterable if condition]

Il est possible d'ajouter une condition à une compréhension de liste pour filtrer les éléments de la séquence source. La syntaxe devient :

[expression for item in iterable if condition]

Seuls les éléments de l'`iterable` pour lesquels la `condition` est vraie sont inclus dans la nouvelle liste.

Exemple : Créer une liste des nombres pairs de 0 à 9

pairs = [x for x in range(10) if x % 2 == 0]
print(pairs)  # Affiche [0, 2, 4, 6, 8]

Exemple : Créer une liste des voyelles d'une chaîne

message = "Bonjour"
voyelles = [lettre for lettre in message if lettre.lower() in 'aeiouy']
print(voyelles) # Affiche ['o', 'o', 'u']

Compréhensions de listes imbriquées : matrices et structures complexes

Il est possible d'imbriquer des compréhensions de listes, ce qui est particulièrement utile pour créer des matrices (listes de listes) ou des structures de données plus complexes.

Exemple : Créer une matrice identité 3x3

matrice_identite = [[1 if i == j else 0 for j in range(3)] for i in range(3)]
print(matrice_identite)  # Affiche [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

Dans cet exemple, la compréhension de liste externe (`for i in range(3)`) itère sur les lignes, et la compréhension de liste interne (`for j in range(3)`) itère sur les colonnes.

L'ordre des `for` imbriqués est le même que dans des boucles `for` imbriquées classiques.

Exemple : "Applatir" une liste de listes.

liste_de_listes = [[1, 2, 3], [4, 5], [6, 7, 8]]
liste_aplatie = [element for sous_liste in liste_de_listes for element in sous_liste]
print(liste_aplatie) # Affiche [1, 2, 3, 4, 5, 6, 7, 8]

Il faut faire attention à la lisibilité lorsqu'on imbrique trop de compréhensions de listes. Dans ce cas, il peut être préférable d'utiliser des boucles `for` classiques.

Alternatives et bonnes pratiques

Même si les compréhensions de liste sont très pratiques, il faut savoir quand les utiliser et connaître leurs alternatives.

Les compréhensions de listes sont un outil puissant, mais il ne faut pas en abuser. Voici quelques recommandations :

• Privilégiez la lisibilité : Si une compréhension de liste devient trop complexe (trop de conditions, trop d'imbrications), il est préférable d'utiliser des boucles `for` classiques, plus explicites.
• N'utilisez pas de compréhensions de listes pour leurs effets de bord : L'objectif d'une compréhension de liste est de créer une nouvelle liste, pas de modifier des variables externes ou d'effectuer d'autres actions.
• Utilisez des fonctions si l'expression devient trop complexe : Si l'expression que vous utilisez dans votre compréhension de liste est trop longue ou trop compliquée, envisagez de la déplacer dans une fonction séparée.

Alternatives aux compréhensions de listes :

• Boucles `for` classiques : Plus verbeuses, mais parfois plus lisibles pour les cas complexes.
• Fonctions `map()` et `filter()` : Des alternatives fonctionnelles aux compréhensions de listes. `map()` applique une fonction à chaque élément d'un itérable, et `filter()` sélectionne les éléments d'un itérable qui satisfont une condition.

Exemple avec `map()` et `filter()` :

nombres = [1, 2, 3, 4, 5]

# Créer une liste des carrés avec map()
carres = list(map(lambda x: x**2, nombres))

# Créer une liste des nombres pairs avec filter()
pairs = list(filter(lambda x: x % 2 == 0, nombres))

En résumé, les compréhensions de listes sont un outil puissant et élégant pour créer des listes en Python, mais il faut les utiliser à bon escient, en privilégiant toujours la clarté et la lisibilité du code.