Biglietti aerei

Un generator è una funzione o un'espressione che restituisce un tipo speciale di iteratore chiamato generator iterator. I Generator-iterator sono pigri: non memorizzano i loro values in memoria, ma generano i loro valori quando servono.

Una funzione generatore è simile a qualsiasi altra funzione, ma contiene una o più espressioni yield. Ogni yield sospende l'esecuzione del codice, salvando lo stato di esecuzione corrente (comprese tutte le variabili locali e le istruzioni try). Quando il generatore riprende, riparte dallo stato in cui era stato sospeso, a differenza delle funzioni normali che si azzerano a ogni chiamata.

Costruire un generatore

I generatori si costruiscono più o meno come le altre funzioni iterative o ricorsive, ma richiedono un'espressione yield, che esploreremo più a fondo tra poco.

Un esempio è una funzione che restituisce i quadrati a partire da un array di numeri. Così com'è scritta, la funzione deve elaborare tutto l'input prima di poter restituire dei valori:

>>> def squares(list_of_numbers):
...     squares = []
...     for number in list_of_numbers:
...         squares.append(number ** 2)
...     return squares

Puoi convertire quella funzione in un generatore così:

>>> def squares_generator(list_of_numbers):
...     for number in list_of_numbers:
...         yield number ** 2

Il motivo è che usi un generatore quando non hai bisogno di produrre tutti i valori in una sola volta. Così risparmi memoria e potenza di calcolo, perché viene calcolato solo il valore su cui stai lavorando in quel momento.

Usare un generatore

I generatori possono essere usati al posto della maggior parte degli iterables in Python. Questo include funzioni o oggetti che richiedono un iterable/iterator come argomento.

Per usare il generatore squares_generator():

>>> squared_numbers = squares_generator([1, 2, 3, 4])

>>> for square in squared_numbers:
...     print(square)
...
1
4
9
16

I valori all'interno di un generator possono anche essere prodotti o recuperati tramite la funzione next(). next() chiama il metodo __next__() di un oggetto generator-iterator, «avanzando» o valutando il codice fino alla sua espressione yield, che a quel punto «produce» o restituisce un valore:

>>> squared_numbers = squares_generator([1, 2])

>>> next(squared_numbers)
1
>>> next(squared_numbers)
4

Quando un generator-iterator è stato consumato del tutto e non ha più valori da restituire, solleva un errore StopIteration.

>>> next(squared_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

L'espressione yield

L'espressione yield è molto simile all'espressione return. A differenza dell'espressione return, yield cede i valori al chiamante in un punto preciso, sospendendo la valutazione o la restituzione di eventuali altri valori finché non vengono richiesti. Quando yield viene valutato, mette in pausa l'esecuzione della funzione che lo contiene e restituisce i valori della funzione in quel preciso momento. La funzione poi rimane nello scope, e quando viene chiamato __next__(), l'esecuzione riprende finché non si incontra di nuovo yield.

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

>>> lets_try = infinite_sequence()
>>> lets_try.__next__()
0
>>> lets_try.__next__()
1

Perché creare un generatore?

I generatori sono utili in molte applicazioni.

Quando lavori con una raccolta di valori potenzialmente grande, potresti non volerli mettere tutti in memoria. Un generatore può essere usato per lavorare su dati più grandi un pezzo alla volta, risparmiando memoria e migliorando le prestazioni.

I generatori sono anche molto utili quando un processo o un calcolo è complesso, costoso o infinito:

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

Ora, ogni volta che viene chiamato __next__() sull'oggetto infinite_sequence, restituirà il numero precedente + 1.