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.
En una línea
Sección titulada «En una línea»yield devuelve un valor y congela la función; la siguiente petición la descongela justo después.
De función a generador
Sección titulada «De función a generador»def contar_hasta(n): i = 0 while i < n: yield i i += 1
g = contar_hasta(3) # no ejecuta nada todavíanext(g) # 0next(g) # 1La 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.
Lo que cuesta
Sección titulada «Lo que cuesta»| 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.
Generadores infinitos
Sección titulada «Generadores infinitos»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.
yield from: delegar
Sección titulada «yield from: delegar»def cadena(*iterables): for it in iterables: yield from ityield 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.
send, throw y close
Sección titulada «send, throw y close»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 yielda.send(10) # 10a.send(5) # 15Eso 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.
Generadores como máquinas de estado
Sección titulada «Generadores como máquinas de estado»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 valorEs 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.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- 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.
Ejercicio
Sección titulada «Ejercicio»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 osimport 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.
Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 05 · Iterables e iteradores: el protocolo que el generador implementa.
- 07 · Pereza: el intercambio memoria/tiempo medido.
- 08 · Context managers: el
withque usan los generadores de archivos.