Compréhensions des listes Python expliquées : quand les utiliser et quand ne pas le faire (2026)
La compréhension des listes est l'une des fonctionnalités les plus mal comprises de Python. Les débutants les évitent car « ils ont l’air compliqués ». Les intermédiaires en abusent jusqu'à ce qu'une ligne sur trois soit une ligne imbriquée que personne ne peut lire. Ce tutoriel corrige les deux erreurs.
Nous aborderons : la forme exacte en trois parties que suit chaque compréhension de liste, les repères par rapport à "pour" / "carte" / "filtre", les quatre modèles que vous devez reconnaître à vue et une règle stricte pour savoir quand arrêter d'utiliser les compréhensions et atteindre une boucle simple à la place.
La forme : [ quoi | source | filtrer ]
Chaque compréhension de liste comprend trois parties, dans cet ordre :
En le lisant à haute voix : "donnez-moi une `expression` pour chaque `élément` dans `iterable`, mais seulement lorsque la `condition` est vraie."
Commencez par la boucle for équivalente, puis réduisez-la :
Même résultat — [0, 4, 16, 36, 64]. La compréhension est une ligne, alloue la liste à l'avance (pas d'appels « append ») et le compilateur de bytecode de Python émet « LIST_APPEND » — un chemin rapide qui ignore la recherche d'attribut sur « .append ».
Benchmark : compréhension vs boucle for vs map+filtre
Construire une liste de nombres pairs au carré de 0 à 100 000 :
| Méthode | Temps (µs) | Relatif |
|---|---|---|
| pour + .append | 4 800 | 1,9× ligne de base |
| liste(carte(..., filtre(...))) | 3 200 | 1,3× ligne de base |
| Compréhension de la liste | 2 500 | 1,0× (le plus rapide) |
Mesuré sur Python 3.13, exécution unique de 1 000 itérations. Les compréhensions gagnent car il n'y a pas d'appel de fonction par élément - l'expression est en ligne.
Cela dit : ne faites pas de micro-optimisation. Pour une liste de 100 éléments, les trois se complètent en moins de 100 µs. Choisissez d'abord la lisibilité.
Les quatre modèles que vous devez reconnaître
1. Transformez chaque élément
Remplacement immédiat de map(str.title, names) mais n'a pas besoin d'encapsuler list(...).
2. Filtrer sans transformer
Plus propre que list(filter(lambda n: n > 0,numbers)). Aucun « lambda » n'est nécessaire.
3. Filtrer ET transformer
C'est là que les compréhensions battent clairement les alternatives — essayez de l'écrire avec map + filter et comptez les parenthèses.
4. Aplatir une liste imbriquée
L'ordre est important : "for row in Matrix" se lit de gauche à droite comme les boucles "for" imbriquées équivalentes. C'est le seul modèle où les compréhensions imbriquées restent lisibles – tout ce qui est plus profond a besoin d'une boucle.
Quand arrêter d'utiliser les compréhensions
Trois règles strictes, par ordre d'importance :
1. Trois clauses « for » ou plus → utilisez une boucle. Une compréhension triplement imbriquée est illisible même pour la personne qui l'a écrite il y a 20 minutes.
2. Effets secondaires → utilisez une boucle. Les compréhensions servent à construire une liste. Si vous appelez une fonction pour ses effets secondaires (écriture dans un fichier, envoi d'une requête), utilisez une boucle. [print(x) for x in items] est une odeur de code — vous créez une liste jetable de Aucun.
3. L'expression comporte plus de 60 caractères → divisez-la. Si vous devez réfléchir pendant plus de 3 secondes pour l'analyser, divisez-la en une fonction nommée ou une boucle.
Compréhensions de dictées et d'ensembles — même forme
Même syntaxe, parenthèses différentes :
Les compréhensions de dict sont particulièrement utiles pour inverser un mappage ({v : k for k, v in d.items()}) ou construire une table de recherche à partir d'une liste.
Expressions génératrices — le cousin respectueux de la mémoire
Lâchez les parenthèses, conservez les parenthèses :
Pour sum, min, max, any, all, ", ".join(...) et d'autres fonctions qui itèrent une fois, préférez l'expression génératrice - elle enregistre l'allocation de liste intermédiaire. Pour tout ce que vous devez indexer ou itérer deux fois, utilisez une compréhension.
Pratique : trois exercices
Réécrivez chacun en utilisant une compréhension de liste. Les solutions sont à la fin.
1. Étant donné words = ["cat", "elephant", "dog", "hippopotamus"], obtenez une liste de mots de plus de 4 caractères, tous en majuscules.
2. Étant donné data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}], extrayez une liste de noms uniquement.
3. Étant donné « paires = [(1, 2), (3, 4), (5, 6)] », obtenez une liste des sommes de chaque paire.
Solutions :
La compréhension des listes est une fonctionnalité caractéristique de Python : savoir quand en atteindre une (et quand la laisser sous forme de boucle « for ) est un marqueur fiable de la maîtrise de niveau intermédiaire. Entraînez-vous en réécrivant les boucles for + .append existantes que vous trouvez dans votre propre code ; tout le monde ne devrait pas devenir une compréhension, mais ceux qui devraient sembler évidents après une semaine.
Prochaine étape : essayez 5 leçons interactives sur la compréhension de listes avec du vrai Python exécuté dans votre navigateur et un mentor IA à chaque étape.