Saltearse al contenido

Generadores

Un generador es una función que puede devolver varios valores, uno por vez, recordando dónde se quedó. No es una lista perezosa: es una función suspendida. Esa diferencia importa porque explica el coste —un 23 % más por elemento en la medición del capítulo— y las reglas: se agota, no se puede reiniciar y no se puede recorrer dos veces.

yield devuelve un valor y congela la función; la siguiente petición la descongela justo después.

def contar_hasta(n):
i = 0
while i < n:
yield i
i += 1
g = contar_hasta(3) # no ejecuta nada todavía
next(g) # 0
next(g) # 1

La llamada no ejecuta el cuerpo: crea un objeto generador. El cuerpo avanza con cada next, y el estado local (i) sobrevive entre llamadas porque vive en el marco de pila, que no se destruye sino que se suspende.

Cuando la función termina, el generador lanza StopIteration y se cierra. A partir de ahí, todos los next vuelven a lanzarla.

Recorrer 100 000 elementos
Forma Tiempo
list plana 2.69 ms
Generador con yield 3.30 ms
Clase con __next__ 9.86 ms

python mediciones/03-05-08-iteracion.py

Un 23 % sobre la lista, y tres veces menos que la clase equivalente. Es el precio de la suspensión: guardar y restaurar el marco en cada elemento. A cambio, el generador no materializa nada, y el capítulo 07 mide lo que eso ahorra en memoria.

Un generador puede no terminar, y eso no es un problema si el consumidor pone el límite:

import itertools
def naturales():
n = 0
while True:
yield n
n += 1
list(itertools.islice(naturales(), 5)) # [0, 1, 2, 3, 4]

islice corta sin materializar. Es el patrón de los lectores de archivos grandes, de los flujos de red y de los pipelines de datos: nadie construye la lista completa.

def cadena(*iterables):
for it in iterables:
yield from it

yield from delega en otro iterable y propaga send, throw y close. En la práctica, se usa para aplanar estructuras y para componer generadores sin escribir el bucle interno.

Un generador puede recibir valores además de producirlos:

def acumulador():
total = 0
while True:
x = yield total
total += x
a = acumulador()
next(a) # 0 — arranca hasta el primer yield
a.send(10) # 10
a.send(5) # 15

Eso es una corrutina, y es la base de asyncio. Para código normal, send se usa poco: si necesitas un acumulador, una clase o itertools.accumulate se leen mejor.

Como el generador conserva su estado entre llamadas, sirve para escribir un proceso que avanza por fases sin una clase y sin variables globales:

def validador():
vistos = set()
while True:
valor = yield
if valor in vistos:
print(f"duplicado: {valor}")
else:
vistos.add(valor)
yield valor

Es más legible que una clase con tres atributos cuando el estado es una secuencia de pasos, y mucho más cuando el proceso tiene estados que no deberían poder alcanzarse desde otros. La clase sigue ganando si hay que inspeccionar el estado o ramificar desde fuera.

  • Si vas a recorrer varias veces. Materializa en una lista.
  • Si necesitas len, índices o slicing. Un generador no los tiene.
  • Si el consumidor exige una secuencia. Muchas APIs aceptan cualquier iterable; algunas hacen len() o indexan, y fallan con un generador.
  • Si el coste por elemento domina. En un bucle interno de millones de operaciones, la lista es entre un 20 % y un 35 % más rápida según la máquina.

Escribe un pipeline de tres generadores que lea números de un archivo de texto, descarte los que no son válidos y devuelva los pares al cuadrado. Explica por qué no hace falta leer el archivo entero en memoria.

Solución
def leer(ruta):
with open(ruta, encoding="utf-8") as f:
for linea in f:
yield linea.strip()
def validos(lineas):
for linea in lineas:
try:
yield int(linea)
except ValueError:
continue
def pares_al_cuadrado(numeros):
for n in numeros:
if n % 2 == 0:
yield n * n
import os
import tempfile
ruta = os.path.join(tempfile.gettempdir(), "numeros.txt")
with open(ruta, "w", encoding="utf-8") as f:
f.write("1\n2\nx\n4\n5\n6\n")
resultado = list(pares_al_cuadrado(validos(leer(ruta))))
print(resultado)

Cada generador procesa una línea y pasa el control al siguiente. La memoria es la de una línea más los objetos del list final; si en lugar de list se suma o se escribe a otro archivo, no se materializa nada.

El with dentro de leer es importante: si el consumidor abandona el generador a medias, el finally implícito del with cierra el archivo. Sin él, el descriptor queda abierto hasta que el recolector pase.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 17: generadores y corrutinas clásicas.
  • CPython 3.13: Objects/genobject.c.
  • Mediciones: mediciones/03-05-08-iteracion.py.
  • 05 · Iterables e iteradores: el protocolo que el generador implementa.
  • 07 · Pereza: el intercambio memoria/tiempo medido.
  • 08 · Context managers: el with que usan los generadores de archivos.