Immagina di caricare un file di registro da 10 GB in un elenco solo per trovare gli errori. Il tuo programma potrebbe esaurire la memoria prima di trovarne una. I generatori Python risolvono questo problema producendo valori su richiesta, uno alla volta, in modo da poter lavorare su dati enormi o addirittura infiniti quasi senza memoria.

Questa guida mostra passo dopo passo cosa succede realmente quando un generatore è in funzione. Abbiamo eseguito ogni esempio su Python 3.13 e l’output proviene da quell’esecuzione. Aiuta a sentirsi già a proprio agio con le funzioni e i loop, che copre il nostro tutorial Python per principianti.

Cos’è un generatore?

Un generatore è un tipo speciale di iteratore che crei scrivendo una funzione utilizzando yield. Qualsiasi funzione con yield al suo interno diventa automaticamente una funzione generatrice e chiamandola si ottiene un oggetto generatore anziché eseguire il codice.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Si noti che “starting” non è stato stampato. La chiamata alla funzione ha creato solo il generatore. All’interno non è ancora partito nulla.

Come funziona la resa, passo dopo passo

Ogni chiamata a next() esegue la funzione finché non raggiunge un yield, restituisce quel valore e si blocca sul posto. La chiamata successiva riprende subito dopo quella riga, con ogni variabile locale intatta.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Seguire attentamente l’output. “starting” appare solo sul primo next(). Nel secondo, l’esecuzione continua da dove si era fermata, quindi n è ancora disponibile e diventa 2. Nel terzo, il ciclo termina, viene stampato “finito”, la funzione cade dalla fine e Python solleva StopIteration per segnalare che non è rimasto nulla.

Raramente chiami next() te stesso. Un ciclo for lo fa per te e gestisce StopIteration in silenzio, così come list(), sum() e funzioni simili:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

rendimento vs rendimento

Questo ritardo è noto come valutazione pigra: i valori vengono elaborati solo quando necessario. Un semplice return all’interno di un generatore semplicemente lo termina, il che attiva StopIteration.

La differenza di memoria, misurata

Abbiamo confrontato un elenco di un milione di quadrati con un generatore equivalente, utilizzando sys.getsizeof:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

La struttura stessa dell’elenco occupava circa 8,4 MB, mentre il generatore occupava solo 200 byte sul nostro sistema. Il divario reale è ancora più grande, poiché getsizeof non conta gli oggetti interi all’interno della lista. Anche la dimensione del generatore rimane la stessa per un miliardo di elementi, poiché memorizza solo lo stato corrente e non i risultati.

C’è un compromesso, però. Un elenco può essere riutilizzato, indicizzato e misurato con len(). Un generatore non offre nessuno di questi. Se è necessario un accesso casuale o si esegue il loop più volte su una piccola quantità di dati, un elenco è più semplice. Consulta la nostra guida su Elenco Python vs tuple vs set per ulteriori informazioni su questi tipi.

Espressioni del generatore

Per i casi semplici, non è necessaria una funzione. Un’espressione del generatore assomiglia a una comprensione di elenco con parentesi tonde al posto di quelle quadre:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Quando un’espressione del generatore è l’unico argomento di una funzione, come in sum(), puoi tralasciare le parentesi extra. Si tratta di un’abitudine ordinata per i totali su dati di grandi dimensioni, poiché non viene creato alcun elenco temporaneo.

Costruisci una pipeline di dati

È qui che i generatori brillano davvero. Piccoli generatori possono essere concatenati in modo che ogni elemento scorra attraverso ogni passaggio, uno alla volta:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Ogni passaggio svolge un piccolo lavoro e può essere testato da solo. Nell’uso reale, scambia l’elenco di esempio con un file aperto, perché gli oggetti file possono essere letti riga per riga, come mostra la nostra guida alla gestione dei file Python. Anche un registro di più gigabyte passerebbe quindi con pochissima memoria.

Sequenze infinite

Una lista non può essere infinita, ma un generatore sì, perché calcola sempre e solo il valore successivo. Usa itertools.islice per prenderne quanti ne hai bisogno:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Fai attenzione, però: la chiamata list(fibonacci()) senza limite verrà eseguita fino a quando la tua memoria non sarà esaurita. Lo stesso modello si adatta ai generatori di ID, ai cicli di polling e ai risultati API impaginati, in cui si recupera la pagina successiva solo quando si esaurisce quella corrente.

resa da e lotti

yield from passa a un altro iterabile, salvandoti un ciclo nidificato:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Uno schema molto pratico è quello di suddividere i dati in batch di dimensioni fisse, ad esempio per inserire un migliaio di righe alla volta in un database:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

L’ultimo if batch assicura che un gruppo rimanente più piccolo non vada perso. Python 3.12 e versioni successive includono anche itertools.batched, che svolge un lavoro simile.

invia, chiudi e pulisci

I generatori possono anche ricevere valori. send() riprende il generatore e il valore diventa il risultato dell’espressione yield. Devi chiamare next() una volta per raggiungere il primo yield:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

La maggior parte delle persone ne ha raramente bisogno. Una preoccupazione più comune è la pulizia. Se ti fermi prima, un blocco finally viene comunque eseguito quando il generatore è chiuso:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest utilizza proprio questa idea: un dispositivo con yield esegue successivamente la pulizia, come dimostra il nostro tutorial pytest. Allo stesso modo, il decoratore contextmanager della libreria standard trasforma un generatore in un blocco with.

Generatori nelle classi

Scrivere un metodo __iter__ come generatore è il modo più semplice per rendere iterabile la tua classe. Un vantaggio è che ogni ciclo riceve un nuovo generatore, quindi l’oggetto può essere ripetuto ancora e ancora:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Quando utilizzare un generatore

Un generatore non è sempre complessivamente più veloce. Se si finisce per utilizzare tutti i valori, il lavoro totale è simile e la comprensione di un elenco può essere anche più rapida per dati di piccole dimensioni poiché comporta un minor sovraccarico per elemento. I vantaggi principali sono l’utilizzo della memoria e l’ottenimento dei primi risultati in tempi più rapidi.

Errori comuni

Riutilizzare un generatore esaurito

Questo cattura quasi tutti ad un certo punto. Un generatore ricorda che è finito:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

La seconda chiamata ottiene un elenco vuoto senza alcun errore. Chiama di nuovo la funzione per ottenere un nuovo generatore o usa l’approccio di classe mostrato sopra.

Previsto che il codice venga eseguito immediatamente

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

I controlli degli argomenti nella parte superiore di un generatore non vengono eseguiti fino al primo next(), quindi gli errori possono apparire lontani dalla chiamata che li ha causati.

Altre trappole

• Chiamare len() o indicizzare. I generatori non supportano nessuno dei due e rilanciano a TypeError.
• Chiudere un file troppo presto. Restituire un generatore dall’interno di un blocco with può significare che il file si chiude prima che venga letta qualsiasi riga. Metti il ​​yield all’interno del blocco with.
• Racchiudere tutto in list(). Ciò elimina il beneficio della memoria.
• Utilizzarne uno per dati di piccole dimensioni. Un elenco semplice è spesso più chiaro.

Considerazioni finali

Un generatore è una funzione che può mettere in pausa. Quell’idea ti offre un basso utilizzo della memoria, sequenze infinite e pipeline pulite. Per metterlo in pratica, trova un punto nel tuo codice che costruisca un lungo elenco solo per ripeterlo una volta e trasformalo in un generatore. Quindi prova a concatenare due piccoli generatori su un vero file di registro.

Domande frequenti

Continua a imparare