Generatori in Python: yield, iterazione lazy e generator expression

Una funzione che si mette in pausa

Un generatore sembra una funzione normale, ma invece di calcolare un risultato completo e restituirlo, cede un valore alla volta con yield, mettendosi in pausa tra un valore e l'altro finché chi lo usa non chiede il successivo.

Il più semplice possibile:

def count_up_to(n):
    current = 1
    while current <= n:
        yield current
        current += 1

for number in count_up_to(5):
    print(number)

Nota yield al posto di return. La prima volta che il for chiede un valore, Python esegue il corpo della funzione finché non incontra yield 1. La funzione si ferma proprio lì, passa 1 al ciclo e ricorda esattamente dove si è fermata, variabili comprese. L'iterazione successiva riparte da dove si era interrotta: current += 1, di nuovo al while, yield 2. E così via finché la condizione del ciclo non diventa falsa: a quel punto il generatore semplicemente si ferma.

Tutto il trucco sta in questo mettersi in pausa e ripartire.

Perché non costruire semplicemente una lista?

Perché la versione con la lista alloca tutti i valori in anticipo:

def count_up_to_list(n):
    return list(range(1, n + 1))

print(count_up_to_list(5))

Va bene per 5 elementi. Ora immagina di volere 50 milioni di interi, e che ti interessi solo il primo che soddisfa una certa condizione. La versione con la lista alloca 50 milioni di interi e poi ne butti via quasi tutti. La versione con il generatore ne crea esattamente quanti ne consuma chi chiama. Quando il ciclo for trova quello che cerca ed esce con break, il generatore semplicemente si ferma.

È questo lo schema da interiorizzare: i generatori ti permettono di scrivere codice di iterazione senza decidere in anticipo quanta parte del risultato ti servirà.

Generator expression

Se hai scritto una list comprehension, conosci già la sintassi: sostituisci le parentesi quadre con quelle tonde:

# List comprehension: alloca l'intero risultato.
squares_list = [n * n for n in range(10)]

# Generator expression: calcola su richiesta.
squares_gen = (n * n for n in range(10))

print(squares_list)
print(squares_gen)

for s in squares_gen:
    print(s)

squares_gen non calcola ancora niente. È solo una ricetta. Scorrerlo esegue la ricetta un passo alla volta.

Le generator expression sono perfette come argomenti per le funzioni che consumano un iterabile:

numbers = [3, 8, 1, 5, 4, 9, 2]

print(sum(n * n for n in numbers))
print(max(n for n in numbers if n % 2 == 0))
print(any(n > 7 for n in numbers))

Nessuna lista intermedia. sum, max e any leggono i valori uno alla volta, che è esattamente quello che vogliono.

Leggere un file grande, riga per riga

È il caso reale per eccellenza dei generatori: elaborare un file troppo grande per caricarlo in memoria:

def parse_log_lines(path):
    with open(path) as f:
        for line in f:
            if line.startswith("ERROR"):
                yield line.rstrip()

for error in parse_log_lines("app.log"):
    print(error)

Il file viene letto in modo lazy. Ogni richiesta al generatore prende una riga dal disco, la filtra e la cede. L'uso della memoria resta costante a prescindere dalla dimensione del file.

Una volta e basta

Un generatore si può attraversare una volta sola. Dopo che l'hai scorso fino in fondo, è esaurito:

def first_three():
    yield 1
    yield 2
    yield 3

gen = first_three()

for n in gen:
    print("first time:", n)

for n in gen:
    print("second time:", n)

Il secondo ciclo non stampa niente. Al generatore non è rimasto nulla.

Se devi scorrere più di una volta, chiama di nuovo la funzione generatore per averne uno nuovo, oppure raccogli la sequenza con list(...) e scorri la lista quante volte vuoi. Scegli in base al costo: ricostruire va bene se il lavoro costa poco; una lista va bene se la sequenza è piccola.

next() e l'iterazione manuale

Non sei obbligato a usare un ciclo for. next() estrae un valore alla volta:

def ticks():
    yield "first"
    yield "second"
    yield "third"

gen = ticks()

print(next(gen))
print(next(gen))
print(next(gen))

# Una quarta chiamata solleverebbe StopIteration.

StopIteration è il modo in cui un generatore segnala "ho finito". I cicli for lo catturano in silenzio. Nel codice manuale puoi passare un valore predefinito a next(gen, default) per evitare l'eccezione.

Generatori infiniti

Visto che i valori vengono prodotti su richiesta, un generatore può rappresentare una sequenza senza fine, purché chi la consuma a un certo punto smetta di chiedere:

def naturals():
    n = 1
    while True:
        yield n
        n += 1

for n in naturals():
    if n > 5:
        break
    print(n)

Un while True con dentro uno yield non blocca il programma: significa solo "se qualcuno continua a chiedere, continua a produrre". È chi consuma a decidere quando fermarsi.

Questo schema compare nei flussi di dati in streaming, negli event loop e ovunque tu prenda valori da una sorgente che non ha una lunghezza definita.

yield from: delegare a un altro iterabile

Se il tuo generatore vuole cedere tutti i valori di un altro iterabile, yield from lo fa in una riga:

def chain(*iterables):
    for it in iterables:
        yield from it

combined = chain([1, 2, 3], (4, 5, 6), "ab")
for x in combined:
    print(x)

Senza yield from scriveresti un ciclo for annidato con dentro yield x. Inoltra anche correttamente le chiamate a send() e throw(), se mai le userai, ma per il codice di tutti i giorni pensalo come "cedi ogni valore di questa cosa".

Quando usare un generatore

Tre segnali che un generatore è lo strumento giusto:

1. La sequenza è grande, forse infinita, o costosa da produrre per intero.
2. Chi la consuma potrebbe fermarsi prima della fine (per esempio con un break alla prima corrispondenza).
3. Vuoi concatenare trasformazioni (filtrare, mappare, prendere i primi n) senza costruire liste intermedie.

E quando non usarlo:

• Ti serve l'accesso casuale (seq[42]). I generatori vanno solo avanti.
• Devi scorrere la stessa sequenza più volte. Usa una lista.
• La sequenza è piccola e ce l'hai già. Una list comprehension è più semplice.

Generatori, list comprehension e liste semplici sono ognuno la risposta giusta per lavori diversi. L'abilità sta nello sceglierne uno senza pensarci troppo, e il modo più rapido per sviluppare questo istinto è chiederti, per ogni iterazione che scrivi, se è meglio "produrre tutto subito" o "produrre un elemento alla volta".

Prossimo argomento: i context manager nel dettaglio

Ora hai visto la maggior parte degli idiomi che Python usa per l'iterazione. Il prossimo argomento sono i context manager, cioè l'istruzione with, che si abbinano bene ai generatori per leggere in streaming dati da file e connessioni di rete.