Bilhetes de avião

Um generator é uma função ou expressão que devolve um tipo especial de iterador chamado generator iterator. Os Generator-iterators são preguiçosos: não guardam os seus values em memória, mas geram os seus valores quando é preciso.

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

Construir um gerador

Os geradores são construídos de forma muito semelhante a outras funções com ciclos ou recursivas, mas exigem uma expressão yield, que vamos explorar em detalhe um pouco mais à frente.

Um exemplo é uma função que devolve os quadrados de uma determinada lista de números. Tal como está escrita, todos os dados de entrada têm de ser processados antes de se poder devolver algum valor:

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

Podes converter essa função num gerador assim:

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

A razão para isto é que usas um gerador quando não precisas de produzir todos os valores de uma só vez. Isto poupa memória e poder de processamento, uma vez que só é calculado o valor com que estás a trabalhar neste momento.

Utilizar um gerador

Os geradores podem ser usados em vez da maioria dos iterables em Python. Isto 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 ou acedidos através da função next(). next() chama o método __next__() de um objeto gerador-iterador, "avançando" ou avaliando o código até à sua expressão yield, que depois "cede" ou devolve um valor:

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

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

Quando um generator-iterator é totalmente consumido e já não tem mais valores para devolver, 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 semelhante à expressão return. Ao contrário da expressão return, o yield cede valores a quem o chama num ponto específico, suspendendo a avaliação ou o retorno de quaisquer valores adicionais até que sejam pedidos. Quando o yield é avaliado, pausa a execução da função que o contém e devolve os valores da função nesse momento. A função permanece então no âmbito, e quando __next__() é chamado, a execução é retomada até o yield voltar a ser encontrado.

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

Porquê criar um gerador?

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

Quando trabalhas com uma coleção de valores potencialmente grande, podes não querer colocá-los todos em memória. Um gerador pode ser usado para trabalhar com dados maiores peça a peça, poupando memória e melhorando o desempenho.

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

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

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