Python : Maîtrisez les listes en compréhension (list comprehension) — Guide complet

De la boucle à l’expression one-liner

Vous écrivez encore des boucles for à rallonge pour construire vos listes en Python ? Vous avez croisé ce genre de code et vous vous êtes demandé comment ça marche ?

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

Bienvenue dans le monde des listes en compréhension (ou list comprehensions en anglais). C’est l’une des fonctionnalités les plus élégantes de Python, et la maîtriser va transformer votre façon d’écrire du code. Dans ce tutoriel, on va voir ensemble, étape par étape, comment les utiliser, les combiner, et surtout… ne pas en abuser.

1. Le problème : la boucle classique

Imaginez que vous vouliez générer une liste des carrés des nombres de 0 à 9. La façon la plus naturelle quand on débute, c’est une boucle for :

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

print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ça fonctionne parfaitement. Mais c’est long à écrire, et surtout… c’est bruyant. On a 4 lignes pour exprimer une idée simple.

Quand on lit ce code, le cerveau doit traiter la création de la liste vide, l’initialisation de la boucle, l’append, avant d’arriver au cœur de l’intention : « je veux une liste de carrés ».

2. La solution : la liste en compréhension

Python nous offre une syntaxe plus concise et plus expressive :

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

Une seule ligne. L’intention est immédiate : « pour chaque x dans la série 0-9, mets x² dans la liste ». C’est plus rapide à écrire, plus rapide à lire, et même légèrement plus rapide à exécuter.

La structure, décomposée

Une liste en compréhension suit toujours le même schéma :

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

Exercice minute : Écrire une liste des cubes de 1 à 10. Essayez par vous-même avant de lire la solution.

cubes = [x**3 for x in range(1, 11)]
print(cubes)  # [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

Facile, non ?

3. Filtrer avec if

Le vrai super-pouvoir des listes en compréhension, c’est la possibilité d’ajouter une condition de filtrage. Reprenons notre liste de carrés, mais cette fois on ne veut garder que les nombres pairs :

# Version boucle
even_squares = []
for x in range(10):
    if x % 2 == 0:
        even_squares.append(x ** 2)

# Version compréhension
even_squares = [x**2 for x in range(10) if x % 2 == 0]

print(even_squares)  # [0, 4, 16, 36, 64]

La syntaxe complète devient :

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

Le if se place après la boucle, et avant la fin des crochets. Simple et logique.

Cas pratique : filtrer les mots d’une phrase

phrase = "Python est un langage de programmation formidable et puissant"
mots_long = [mot for mot in phrase.split() if len(mot) > 7]
print(mots_long)  # ['programmation', 'formidable', 'puissant']

En une ligne, on a splitté la phrase, parcouru chaque mot, filtré ceux de plus de 7 lettres, et construit la liste. Essayez de faire ça en 4 lignes avec une boucle — c’est possible, mais moins élégant.

4. Les boucles imbriquées (et quand les utiliser)

On peut aussi avoir plusieurs for dans une même compréhension. C’est l’équivalent d’une boucle imbriquée :

# Version boucle
pairs = []
for x in [1, 2, 3]:
    for y in [10, 20, 30]:
        pairs.append((x, y))

# Version compréhension
pairs = [(x, y) for x in [1, 2, 3] for y in [10, 20, 30]]

print(pairs)
# [(1, 10), (1, 20), (1, 30), (2, 10), (2, 20), (2, 30), (3, 10), (3, 20), (3, 30)]

⚠️ Attention : Dès qu’on dépasse deux boucles, une compréhension devient difficile à lire. Dans ce cas, préférez une boucle classique. La lisibilité prime toujours !

5. Compréhensions avec condition ternaire

On peut aussi utiliser un opérateur ternaire dans l’expression pour un traitement conditionnel :

# "pair" si pair, "impair" sinon
labels = ["pair" if x % 2 == 0 else "impair" for x in range(6)]
print(labels)  # ['pair', 'impair', 'pair', 'impair', 'pair', 'impair']

Attention à ne pas confondre avec le if filtrant ! La règle est simple :

• [x for x in liste if condition] → filtre les éléments
• [vrai if condition else faux for x in liste] → transforme chaque élément

6. Aller plus loin : dictionnaire et set en compréhension

Le même principe existe pour les dictionnaires et les ensembles :

# Dictionnaire : {clé: valeur for élément in itérable}
carrés = {x: x**2 for x in range(5)}
print(carrés)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Set (ensemble) : {expression for élément in itérable}
nombres = [1, 2, 2, 3, 3, 3, 4]
pairs_uniques = {x for x in nombres if x % 2 == 0}
print(pairs_uniques)  # {2, 4}

Les dictionnaires en compréhension sont particulièrement utiles pour transformer des données ou créer des index rapidement.

7. Pièges à éviter

❌ Trop de complexité

Si votre compréhension tient sur 2-3 lignes, vous pouvez le faire, mais devriez-vous ?

# À ÉVITER — trop complexe
result = [[w.upper() for w in s.split() if len(w) > 3] for s in phrases if s.strip()]

# MIEUX — plus lisible
result = []
for s in phrases:
    if s.strip():
        mots = [w.upper() for w in s.split() if len(w) > 3]
        result.append(mots)

❌ Négliger la mémoire

Une liste en compréhension construit toute la liste en mémoire d’un coup. Pour des gros volumes, préférez un générateur :

# Liste — tout en mémoire
squares_list = [x**2 for x in range(1_000_000)]

# Générateur — paresseux (évalué à la demande)
squares_gen = (x**2 for x in range(1_000_000))  # Notez les parenthèses !

❌ Effets de bord

Une compréhension est faite pour construire une liste, pas pour exécuter des actions avec effets de bord (comme print() ou écrire dans un fichier). Si vous avez besoin d’effets de bord, utilisez une boucle for.

8. Exercice récapitulatif

Mettez en pratique tout ce que vous avez appris :

1. Facile : Générez une liste des 10 premiers multiples de 3.
2. Moyen : À partir d’une liste de températures en Celsius, convertissez-les en Fahrenheit. Formule : F = C × 9/5 + 32.
3. Avancé : À partir d’une chaîne contenant des mots séparés par des espaces, créez un dictionnaire qui associe chaque mot unique à sa longueur.

# 1. Multiples de 3
[x * 3 for x in range(1, 11)]

# 2. Celsius vers Fahrenheit
celsius = [0, 10, 20, 30, 37, 100]
[c * 9/5 + 32 for c in celsius]
# Résultat : [32.0, 50.0, 68.0, 86.0, 98.6, 212.0]

# 3. Mot → longueur
phrase = "Python est un langage puissant et expressif"
{mot: len(mot) for mot in phrase.split()}
# Résultat : {'Python': 6, 'est': 3, 'un': 2, ...}

Ce qu’il faut retenir

• ✅ Les listes en compréhension rendent le code plus concis et plus expressif
• ✅ On peut filtrer avec if et transformer avec des expressions
• ✅ Dictionnaires et sets ont leur propre syntaxe en compréhension
• ✅ La lisibilité passe avant la concision — 2 boucles max, pas de logique trop complexe
• ✅ Pour les grands volumes, pensez aux générateurs plutôt qu’aux listes

Maîtriser les compréhensions, c’est adopter un style Pythonique qui fait la différence entre un code qui « marche » et un code qui se lit comme une phrase. C’est exactement le genre de compétence qu’on travaille et consolide dans nos formations pratiques.

Et vous ? Quelle est votre utilisation préférée des listes en compréhension ? Un cas où ça vous a sauvé des lignes de code ? Racontez-nous en commentaire ! 👇

Photo de Myburgh Roux sur Pexels.

Envie d’aller plus loin ? Découvrez nos formations pratiques pour maîtriser Python et le développement — avec un vrai formateur qui vous guide pas à pas.