Cosa sono i generator e la parola chiave yield?

Question

IT Interview Practice · 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.

yield vs return

Il vantaggio della memoria

Sequenze infinite (impossibili con una lista)

Come funziona l'iterazione sotto il cofano

Espressioni generator

Perché è importante

Domande correlate