Une ligne, une idée
Tu as déjà écrit ce motif plusieurs fois : partir d'une liste vide, boucler sur quelque chose, peut-être filtrer, et ajouter au résultat.
Une compréhension de liste dit la même chose en une ligne :
Lis-la de gauche à droite : « une nouvelle liste constituée de n * 2, pour chaque n dans numbers ». La structure est [expression for item in iterable].
Ce n'est pas une astuce propre à Python — on appelle ça une compréhension parce que tu décris ce qui va dans la nouvelle liste, de façon déclarative, plutôt que d'écrire la mécanique de comment la construire.
Ajouter un filtre
Ajoute une clause if après la partie boucle pour filtrer :
Lis la seconde comme : « n * n pour chaque n dans numbers, mais seulement si n est impair. »
La boucle équivalente :
Les deux vont très bien. La compréhension est plus courte et, une fois que tu en as lu quelques-unes, en fait plus facile à parcourir parce que l'intention est là en une ligne.
Map et filter combinés
Tu peux lire des valeurs à travers une fonction et filtrer en même temps :
Pour chaque mot plus long que 3 lettres, inclus sa version en majuscules.
Boucles imbriquées dans une compréhension
Deux for produisent une paire de style produit cartésien :
L'ordre est le même que si tu avais imbriqué les boucles : le premier for est l'extérieur, le second l'intérieur. Ça se lit de gauche à droite comme la boucle indentée équivalente.
Deux niveaux, c'est à peu près la limite avant qu'une boucle normale se lise mieux. Si tu atteins trois, retourne aux boucles.
Compréhensions de dictionnaire et de set
Même idée, accolades différentes :
Les compréhensions de set ressemblent à des compréhensions de dict au premier coup d'œil — la différence est le key: value par rapport à une seule expression. Accolades plus : = dict ; accolades sans : = set.
Expressions génératrices
Une quasi-jumelle de la compréhension de liste, mais avec des parenthèses au lieu de crochets — et surtout, elle ne construit pas de liste :
Remarque qu'on a passé le générateur directement à sum() et any() — pas de parenthèses supplémentaires. Les expressions génératrices sont le bon outil quand l'appelant n'a besoin d'itérer qu'une fois. Elles sont plus économes en mémoire qu'une liste complète pour de grandes collections.
Quand utiliser plutôt une boucle normale
Les compréhensions sont séduisantes. Tu peux techniquement bourrer beaucoup dedans. Tu ne devrais pas.
Utilise une boucle simple quand :
- La transformation fait plus d'une étape. Si tu as besoin de variables intermédiaires, écris-la explicitement.
- Il y a de la gestion d'erreur ou du branchement complexes.
- Quiconque lit la ligne doit faire une pause plus d'une fois pour la comprendre.
La règle que j'applique : si je peux lire la compréhension en une seule inspiration et comprendre ce qu'elle fait, elle reste. Si je trébuche, je la réécris en boucle.
Certaines compréhensions ont l'air malines mais font mal :
Même résultat. La version en boucle fait cinq lignes au lieu d'une, mais « plus long » n'est pas pareil que « pire ».
Quelques motifs que tu réutiliseras
Ces cinq motifs couvrent une quantité surprenante de travail quotidien sur les données.
La suite
Tu as maintenant vu les principaux types de collections et la compréhension qui les lie. Chapitre suivant : les fonctions — emballer du comportement dans des unités nommées et réutilisables.
Questions fréquentes
Qu'est-ce qu'une compréhension de liste en Python ?
Une syntaxe compacte pour construire une nouvelle liste à partir d'un itérable existant. [x * 2 for x in numbers] crée une nouvelle liste avec chaque nombre doublé. Tu peux aussi filtrer : [x for x in numbers if x > 0].
Quand ne pas utiliser une compréhension de liste ?
Quand ça nuit à la lisibilité. Si l'expression à l'intérieur est complexe ou profondément imbriquée, une boucle for normale avec des noms de variables convenables est plus claire. Les compréhensions sont pour des transformations simples — mapping et filtrage. Tout ce qui est plus complexe passe mieux dans une boucle complète.
Quelle est la différence entre une compréhension de liste et une expression génératrice ?
Une compréhension de liste construit toute la liste en mémoire. Une expression génératrice (même syntaxe mais avec des parenthèses) produit un élément à la fois. Utilise un générateur quand tu passes les résultats à quelque chose qui itère une fois — comme sum(...) — pour ne pas matérialiser une liste que tu vas immédiatement jeter.
