O que são geradores e a palavra-chave yield?

Question

Accepted Answer

Um **gerador** é uma função que produz valores **preguiçosamente, um de cada vez**, usando a palavra-chave `yield` em vez de `return`. Ele calcula cada valor sob demanda, em vez de construir todo o resultado na memória — ideal para sequências grandes ou infinitas.

## yield vs return

```python
# a regular function builds the WHOLE list in memory
def get_squares(n):
    return [i ** 2 for i in range(n)]   # all n values created at once

# a generator yields values ONE AT A TIME, on demand
def gen_squares(n):
    for i in range(n):
        yield i ** 2                     # pause here, return one value, resume on next()

for sq in gen_squares(1_000_000):        # uses almost NO memory
    print(sq)
```

`yield` **pausa** a função, retorna um valor e **retoma** exatamente do ponto anterior na próxima iteração — preservando o estado local entre valores. Nada é calculado até ser solicitado.

## O benefício de memória

```python
sum(i ** 2 for i in range(10_000_000))   # generator expression — constant memory
sum([i ** 2 for i in range(10_000_000)]) # list — builds a huge list first (wasteful)
```

Para dados grandes, geradores mantêm a memória plana; uma compreensão de lista materializa tudo de uma vez.

## Sequências infinitas (impossível com uma lista)

```python
def count_up():
    n = 0
    while True:        # infinite — but lazy, so it's fine
        yield n
        n += 1

gen = count_up()
next(gen)   # 0
next(gen)   # 1  — only computes when asked
```

Porque valores são produzidos sob demanda, um gerador pode representar um fluxo *infinito* — você apenas pega o que precisa.

## Como a iteração funciona nos bastidores

```python
gen = gen_squares(3)
next(gen)   # 0  — runs until the first yield
next(gen)   # 1  — resumes, runs to the next yield
next(gen)   # 4
next(gen)   # StopIteration — generator exhausted
```

## Expressões geradoras

```python
(x ** 2 for x in range(10))   # like a list comprehension but lazy (parentheses)
```

## Por que isso importa

Geradores são essenciais para o processamento **eficiente em memória** de dados grandes ou em fluxo — lendo arquivos enormes linha por linha, processando grandes conjuntos de dados, pipelines ou sequências infinitas — onde construir uma lista completa esgotaria a memória.

Compreender `yield` (pausa/retomada com estado preservado) e avaliação preguiçosa permite escrever código de processamento de dados escalável, e expressões geradoras proporcionam o mesmo benefício de forma concisa.

São ferramentas essenciais sempre que os dados são muito grandes para caber na memória ou você deseja processar itens conforme são produzidos, em vez de todos antecipadamente.