Cosa sono i generator e la parola chiave yield?

Question

Accepted Answer

Un **generator** è una funzione che produce valori **pigramente, uno alla volta**, usando la parola chiave `yield` al posto di `return`. Calcola ogni valore su richiesta piuttosto che costruire l'intero risultato in memoria — ideale per sequenze grandi o infinite.

## 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` **sospende** la funzione, restituisce un valore, e **riprende** da quel punto esatto nella successiva iterazione — preservando lo stato locale tra i valori. Niente viene calcolato finché non richiesto.

## Il vantaggio della memoria

```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)
```

Per dati grandi, i generator mantengono la memoria piatta; una list comprehension materializza tutto in una volta.

## Sequenze infinite (impossibili con una lista)

```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
```

Poiché i valori vengono prodotti su richiesta, un generator può rappresentare un flusso *infinito* — basta prendere quello di cui hai bisogno.

## Come funziona l'iterazione sotto il cofano

```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
```

## Espressioni generator

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

## Perché è importante

I generator sono essenziali per l'elaborazione **memory-efficient** di dati grandi o in streaming — leggere file enormi riga per riga, elaborare dataset grandi, pipeline, o sequenze infinite — dove costruire una lista intera esaurirebbe la memoria.

Comprendere `yield` (sospensione/ripresa con stato preservato) e la valutazione pigra ti permette di scrivere codice di elaborazione dati scalabile, e le espressioni generator forniscono lo stesso vantaggio in modo conciso.

Sono uno strumento chiave ogni volta che i dati sono troppo grandi per stare in memoria o vuoi elaborare elementi mentre vengono prodotti piuttosto che tutti in anticipo.