Passagens aéreas

Um generator é uma função ou expressão que retorna um tipo especial de iterador chamado generator iterator. Os generator-iterators são preguiçosos: eles não armazenam seus values na memória, mas geram seus valores quando necessário.

Uma função geradora se parece com qualquer outra função, mas contém uma ou mais expressões yield. Cada yield suspende a execução do código e salva o estado de execução atual (incluindo todas as variáveis locais e instruções try). Quando o gerador é retomado, ele recupera o estado a partir do ponto de suspensão, ao contrário das funções comuns, que são reiniciadas a cada chamada.

Construindo um gerador

Os geradores são construídos de forma muito parecida com outras funções de laço ou recursivas, mas exigem uma expressão yield, que veremos em detalhes mais adiante.

Um exemplo é uma função que retorna os quadrados de uma determinada lista de números. Do jeito que está escrita, toda a entrada precisa ser processada antes que qualquer valor possa ser retornado:

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

Você pode converter essa função em um gerador assim:

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

A razão disso é que você usa um gerador quando não precisa produzir todos os valores de uma vez. Isso economiza memória e poder de processamento, já que só o valor com que você está trabalhando no momento é calculado.

Usando um gerador

Os geradores podem ser usados no lugar da maioria dos iterables em Python. Isso inclui funções ou objetos que exigem um iterable/iterator como argumento.

Para usar o gerador squares_generator():

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

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

Os valores dentro de um generator também podem ser produzidos/acessados por meio da função next(). A função next() chama o método __next__() de um objeto gerador-iterador, "avançando" ou avaliando o código até a sua expressão yield, que então "produz" ou retorna um valor:

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

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

Quando um generator-iterator é totalmente consumido e não tem mais valores para retornar, ele lança um erro StopIteration.

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

A expressão yield

A expressão yield é muito parecida com a expressão return. Ao contrário da expressão return, o yield entrega valores ao chamador em um ponto específico, suspendendo a avaliação/retorno de quaisquer valores adicionais até que eles sejam solicitados. Quando o yield é avaliado, ele pausa a execução da função que o contém e retorna quaisquer valores da função naquele momento. A função então permanece no escopo, e quando __next__() é chamado, a execução continua até que o yield seja encontrado novamente.

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

Por que criar um gerador?

Os geradores são úteis em muitas aplicações.

Ao trabalhar com uma coleção potencialmente grande de valores, talvez você não queira colocá-los todos na memória. Um gerador pode ser usado para processar dados maiores peça por peça, economizando memória e melhorando o desempenho.

Os geradores também são muito úteis quando um processo ou cálculo é complexo, custoso ou infinito:

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

Agora, sempre que __next__() for chamado no objeto infinite_sequence, ele retornará o número anterior + 1.