List Comprehensions Python : Écrire moins, faire plus

8 min de lecture Python

Si tu as déjà écrit des boucles for en Python pour construire des listes, tu vas adorer ce que les list comprehensions ont à t'offrir. Cette fonctionnalité, introduite dès Python 2.0 via la PEP 202, permet d'écrire en une seule ligne ce qui demandait auparavant trois à cinq lignes de code. Plus lisible, plus rapide, plus pythonique — les list comprehensions font partie des outils que tout développeur Python doit maîtriser.

Dans ce guide, on va partir de zéro et aller jusqu'aux cas avancés, avec des exemples concrets à chaque étape. Pas de théorie abstraite : on code directement.

La syntaxe de base des list comprehensions

Une list comprehension, c'est une façon compacte de créer une liste à partir d'un itérable. La structure de base est la suivante :

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

Voilà comment ça se lit : "pour chaque élément dans l'itérable, applique l'expression et mets le résultat dans une liste".

Exemple simple : créer une liste des 5 premiers carrés.

# Sans list comprehension
carres = []
for n in range(5):
    carres.append(n ** 2)

# Avec list comprehension
carres = [n ** 2 for n in range(5)]

print(carres)  # [0, 1, 4, 9, 16]

Les deux blocs produisent exactement le même résultat. Mais la version avec list comprehension est plus courte, plus lisible, et — on le verra — légèrement plus rapide à l'exécution.

Ajouter une condition : filtrer les éléments

La puissance des list comprehensions s'exprime vraiment quand on ajoute un filtre. La syntaxe devient :

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

Seuls les éléments pour lesquels la condition est vraie seront inclus dans la liste finale. Par exemple, extraire uniquement les nombres pairs d'une liste :

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

pairs = [n for n in nombres if n % 2 == 0]
print(pairs)  # [2, 4, 6, 8, 10]

On peut aussi combiner transformation et filtrage en même temps :

# Carrés des nombres pairs uniquement
carres_pairs = [n ** 2 for n in range(1, 11) if n % 2 == 0]
print(carres_pairs)  # [4, 16, 36, 64, 100]

La condition se place toujours après la clause for, jamais avant.

List comprehension vs boucle for : comparaison directe

Pour bien comprendre ce que les list comprehensions remplacent, rien de mieux qu'une comparaison côte à côte. Si tu maîtrises déjà la boucle for en Python, la transition sera naturelle.

mots = ["python", "javascript", "rust", "go", "kotlin"]

# VERSION BOUCLE FOR
mots_longs = []
for mot in mots:
    if len(mot) > 4:
        mots_longs.append(mot.upper())

# VERSION LIST COMPREHENSION
mots_longs = [mot.upper() for mot in mots if len(mot) > 4]

print(mots_longs)  # ['PYTHON', 'JAVASCRIPT', 'KOTLIN']

Le résultat est identique. La différence, c'est que la list comprehension est :

Exemples pratiques et concrets

Passons aux cas que tu rencontreras vraiment dans tes projets Python.

Transformer des chaînes de caractères

prénoms = ["alice", "bob", "charlie", "diana"]

# Mettre chaque prénom en majuscule
prénoms_maj = [p.capitalize() for p in prénoms]
print(prénoms_maj)  # ['Alice', 'Bob', 'Charlie', 'Diana']

Filtrer des valeurs dans une liste

notes = [12, 8, 17, 5, 14, 9, 18, 3]

# Garder seulement les notes >= 10
admis = [note for note in notes if note >= 10]
print(admis)  # [12, 17, 14, 18]

Travailler avec des dictionnaires

produits = [
    {"nom": "clavier", "prix": 45},
    {"nom": "souris", "prix": 25},
    {"nom": "écran", "prix": 280},
    {"nom": "webcam", "prix": 65},
]

# Extraire les noms des produits à moins de 100€
pas_chers = [p["nom"] for p in produits if p["prix"] < 100]
print(pas_chers)  # ['clavier', 'souris', 'webcam']

Aplatir une liste de listes

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

plat = [n for ligne in matrice for n in ligne]
print(plat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Les list comprehensions imbriquées (nested)

On peut imbriquer plusieurs clauses for dans une même list comprehension. C'est utile pour travailler avec des structures à plusieurs dimensions.

# Générer des paires (x, y) où x != y
paires = [(x, y) for x in range(1, 4) for y in range(1, 4) if x != y]
print(paires)
# [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

Attention : les comprehensions imbriquées deviennent vite difficiles à lire. Dès qu'on a deux boucles for imbriquées avec des conditions, mieux vaut repasser à une boucle classique ou extraire la logique dans une fonction Python dédiée. La lisibilité prime toujours sur la concision.

# ❌ Difficile à lire (à éviter)
resultat = [traiter(x, y) for x in data1 for y in data2 if valide(x) if compatible(y)]

# ✅ Plus clair avec une boucle classique
resultat = []
for x in data1:
    if valide(x):
        for y in data2:
            if compatible(y):
                resultat.append(traiter(x, y))

Dict comprehensions et set comprehensions

La même logique s'applique aux dictionnaires et aux ensembles. Python propose des syntaxes analogues.

Dict comprehension

mots = ["python", "java", "go"]

# Créer un dictionnaire mot → longueur
longueurs = {mot: len(mot) for mot in mots}
print(longueurs)  # {'python': 6, 'java': 4, 'go': 2}

# Inverser un dictionnaire
original = {"a": 1, "b": 2, "c": 3}
inversé = {v: k for k, v in original.items()}
print(inversé)  # {1: 'a', 2: 'b', 3: 'c'}

Set comprehension

texte = "bonjour le monde"

# Ensemble des lettres uniques (sans doublons, sans espace)
lettres = {c for c in texte if c != " "}
print(lettres)  # ensemble des lettres uniques

La différence avec une list comprehension : les accolades {} au lieu des crochets []. Pour un set, les doublons sont automatiquement supprimés.

Pour en savoir plus sur les structures de données disponibles, la documentation officielle Python est une référence incontournable.

Erreurs courantes des débutants

Voici les pièges que les débutants rencontrent le plus souvent avec les list comprehensions.

Confondre l'ordre des clauses

# ❌ ERREUR : la condition est mal placée → SyntaxError
# resultat = [x if x > 0 for x in liste]

# ✅ CORRECT : la condition de filtre va APRÈS le for
resultat = [x for x in liste if x > 0]

Attention : la syntaxe [valeur_si_vrai if condition else valeur_si_faux for ...] est une expression ternaire (pas un filtre) et se place avant le for :

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

# Remplacer les négatifs par 0 (expression ternaire)
positifs = [n if n > 0 else 0 for n in nombres]
print(positifs)  # [0, 1, 0, 4, 0, 5]

Utiliser une comprehension pour des effets de bord

# ❌ Mauvaise pratique : comprehension juste pour print
[print(x) for x in range(5)]

# ✅ Utiliser une boucle for pour les effets de bord
for x in range(5):
    print(x)

Une list comprehension doit toujours servir à construire une liste. Si tu n'utilises pas le résultat, écris une boucle for classique.

Quand utiliser (et ne pas utiliser) les list comprehensions

Situations idéales

Situations où mieux vaut éviter

La règle d'or : si quelqu'un qui découvre ton code met plus de 5 secondes à comprendre ta comprehension, écris une boucle classique. Python favorise la lisibilité — c'est l'esprit du Zen of Python : "Readability counts".

Générateurs : l'alternative pour les grandes listes

# List comprehension : construit toute la liste en mémoire d'un coup
carres = [n ** 2 for n in range(1_000_000)]

# Générateur : calcule les valeurs à la demande (économe en mémoire)
carres_gen = (n ** 2 for n in range(1_000_000))

# On itère dessus ou on utilise next()
print(next(carres_gen))  # 0

Si tu travailles avec des millions d'éléments, préfère un générateur (parenthèses () au lieu de crochets []).

Conclusion : les list comprehensions, un outil pythonique essentiel

Les list comprehensions Python sont l'un des outils les plus élégants du langage. Elles permettent d'écrire du code plus dense, plus lisible pour les cas simples, et légèrement plus performant. Mais comme tout outil puissant, elles nécessitent un peu de pratique.

Ce que tu dois retenir :

La meilleure façon de maîtriser les list comprehensions, c'est de pratiquer. Si tu veux progresser en Python avec des exercices guidés et un feedback immédiat, jette un œil aux ateliers de code GoGoKodo — tu codes directement dans le navigateur, sans rien installer.

Continue sur ta lancée : explore comment les fonctions Python te permettent d'encapsuler la logique que tu appliques dans tes comprehensions. Et si tu veux consolider ta compréhension des boucles, reviens sur le guide complet de la boucle for en Python — les deux sujets se complètent parfaitement.