Qu'est-ce que les générateurs et le mot-clé yield ?

Question

Accepted Answer

Un **générateur** est une fonction qui produit des valeurs **paresseusement, une à la fois**, en utilisant le mot-clé `yield` au lieu de `return`. Il calcule chaque valeur à la demande plutôt que de construire le résultat entier en mémoire — idéal pour les grandes ou infinies séquences.

## yield vs return

```python
# a regular function builds the WHOLE list in memory
def get_squares(n):
    return [i ** 2 for i in range(n)]   # all n values created at once

# a generator yields values ONE AT A TIME, on demand
def gen_squares(n):
    for i in range(n):
        yield i ** 2                     # pause here, return one value, resume on next()

for sq in gen_squares(1_000_000):        # uses almost NO memory
    print(sq)
```

`yield` **met en pause** la fonction, retourne une valeur et **reprend** à partir du point exact lors de l'itération suivante — en conservant l'état local entre les valeurs. Rien n'est calculé jusqu'à ce qu'il soit demandé.

## L'avantage mémoire

```python
sum(i ** 2 for i in range(10_000_000))   # generator expression — constant memory
sum([i ** 2 for i in range(10_000_000)]) # list — builds a huge list first (wasteful)
```

Pour les grandes données, les générateurs maintiennent la mémoire plate ; une compréhension de liste matérialise tout à la fois.

## Séquences infinies (impossible avec une liste)

```python
def count_up():
    n = 0
    while True:        # infinite — but lazy, so it's fine
        yield n
        n += 1

gen = count_up()
next(gen)   # 0
next(gen)   # 1  — only computes when asked
```

Parce que les valeurs sont produites à la demande, un générateur peut représenter un flux *infini* — vous prenez juste ce dont vous avez besoin.

## Comment l'itération fonctionne sous le capot

```python
gen = gen_squares(3)
next(gen)   # 0  — runs until the first yield
next(gen)   # 1  — resumes, runs to the next yield
next(gen)   # 4
next(gen)   # StopIteration — generator exhausted
```

## Expressions de générateur

```python
(x ** 2 for x in range(10))   # like a list comprehension but lazy (parentheses)
```

## Pourquoi c'est important

Les générateurs sont essentiels pour le traitement **efficace en mémoire** de grandes données ou en continu — lire des fichiers énormes ligne par ligne, traiter de grands ensembles de données, des pipelines ou des séquences infinies — où construire une liste complète épuiserait la mémoire.

Comprendre `yield` (pause/reprise avec état préservé) et l'évaluation paresseuse vous permet d'écrire du code de traitement de données scalable, et les expressions de générateur offrent le même avantage de manière concise.

C'est un outil clé chaque fois que les données sont trop grandes pour tenir en mémoire ou que vous souhaitez traiter les éléments au fur et à mesure qu'ils sont produits plutôt que tous d'avance.