¿Qué son los generadores y la palabra clave yield?

Question

Accepted Answer

Un **generador** es una función que produce valores **de forma perezosa, uno a la vez**, usando la palabra clave `yield` en lugar de `return`. Calcula cada valor bajo demanda en vez de construir el resultado completo en memoria — ideal para secuencias grandes o 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** la función, devuelve un valor y **reanuda** desde ese punto exacto en la siguiente iteración — preservando el estado local entre valores. No se calcula nada hasta que se solicita.

## El beneficio de memoria

```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 datos grandes, los generadores mantienen la memoria plana; una list comprehension materializa todo de una vez.

## Secuencias infinitas (imposible con una 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
```

Como los valores se producen bajo demanda, un generador puede representar un flujo *infinito* — simplemente tomas lo que necesitas.

## Cómo funciona la iteración por dentro

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

## Expresiones generadoras

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

## Por qué es importante

Los generadores son esenciales para el procesamiento **eficiente en memoria** de datos grandes o en streaming — leer archivos enormes línea por línea, procesar grandes conjuntos de datos, pipelines o secuencias infinitas — donde construir una lista completa agotaría la memoria.

Entender `yield` (pausar/reanudar con estado preservado) y la evaluación perezosa te permite escribir código de procesamiento de datos escalable, y las expresiones generadoras ofrecen el mismo beneficio de forma concisa.

Son una herramienta clave siempre que los datos sean demasiado grandes para caber en memoria o cuando quieras procesar elementos a medida que se producen en lugar de todos por adelantado.