Que sont les list comprehensions?

Question

Accepted Answer

Une **list comprehension** est un moyen concis et lisible de construire une liste en transformant et/ou en filtrant un élément itérable dans une seule expression — l'alternative idiomatique de Python à une boucle `for` qui ajoute à une liste.

## Syntaxe de base

```python
# the loop way:
squares = []
for n in range(5):
    squares.append(n ** 2)

# the comprehension way — same result, one line
squares = [n ** 2 for n in range(5)]   # [0, 1, 4, 9, 16]
#          └expr──┘ └──for clause───┘
```

Lisez-le comme "le carré de n, pour chaque n dans range(5)." C'est plus concis et souvent plus rapide que la boucle manuelle.

## Ajouter un filtre (if)

```python
# keep only even numbers
evens = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]

# transform AND filter together
result = [n * 2 for n in range(10) if n % 2 == 0]  # [0, 4, 8, 12, 16]
```

## Expression conditionnelle dans la sortie

```python
# if/else goes BEFORE the for (it's part of the expression, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(4)]
# ["even", "odd", "even", "odd"]
```

## Comprehensions pour d'autres types

```python
{x ** 2 for x in range(5)}             # set comprehension → {0, 1, 4, 9, 16}
{k: v for k, v in pairs}               # dict comprehension
(x ** 2 for x in range(5))             # generator expression — LAZY, memory-efficient
```

La même syntaxe construit des sets et des dicts; avec des parenthèses, elle devient une **generator expression** qui produit des valeurs paresseusement (pas de liste complète en mémoire — idéal pour les grandes données).

## Quand ne pas les utiliser

```python
# ❌ deeply nested / complex logic → a regular loop is more readable
matrix = [[row[i] for row in data] for i in range(cols)]  # OK, but don't over-nest
```

Gardez les comprehensions simples; si elles nécessitent plusieurs boucles imbriquées ou des conditions complexes, une boucle ordinaire est plus claire.

## Pourquoi c'est important

Les list comprehensions sont essentiellement « Pythonicaes » — concises, lisibles et souvent plus rapides que les boucles équivalentes, utilisées constamment pour transformer et filtrer les données.

Les maîtriser (ainsi que leurs variantes set/dict/generator et l'expression générateur paresseuse pour les grandes données) est essentiel pour écrire du Python idiomatique.

Savoir quand les utiliser (transformations/filtres simples) par rapport à une boucle ordinaire (logique complexe) est la marque d'un code propre et lisible.