Imagine cargar un archivo de registro de 10 GB en una lista solo para encontrar los errores. Su programa puede quedarse sin memoria antes de encontrarla. Los generadores de Python resuelven esto al producir valores a pedido, uno a la vez, para que puedas trabajar con datos enormes o incluso infinitos casi sin memoria.

Esta guía muestra lo que realmente sucede cuando un generador funciona, paso a paso. Ejecutamos cada ejemplo en Python 3.13 y el resultado proviene de esa ejecución. Es útil sentirse cómodo con las funciones y los bucles, que cubre nuestro tutorial de Python para principiantes.

¿Qué es un generador?

Un generador es un tipo especial de iterador que se crea escribiendo una función usando yield. Cualquier función con yield se convierte automáticamente en una función generadora y llamarla le proporciona un objeto generador en lugar de ejecutar el código.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Observe que “inicio” no se imprimió. Llamar a la función solo creó el generador. Nada dentro ha funcionado todavía.

Cómo funciona el rendimiento, paso a paso

Cada llamada a next() ejecuta la función hasta que llega a yield, devuelve ese valor y se congela en su lugar. La siguiente llamada se reanuda justo después de esa línea, con todas las variables locales intactas.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Siga la salida con atención. “iniciando” aparece sólo en el primero next(). En el segundo, la ejecución continúa desde donde se detuvo, por lo que n todavía está disponible y se convierte en 2. En el tercero, el ciclo termina, se imprime “terminado”, la función cae al final y Python eleva StopIteration para indicar que no queda nada.

Rara vez te llamas next() a ti mismo. Un bucle for lo hace por usted y maneja StopIteration silenciosamente, al igual que list(), sum() y funciones similares:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

rendimiento versus retorno

Este retraso se conoce como evaluación diferida: los valores se calculan solo cuando es necesario. Un simple return dentro de un generador simplemente lo termina, lo que activa StopIteration.

La diferencia de memoria, medida

Comparamos una lista de un millón de cuadrados con un generador equivalente, usando sys.getsizeof:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

La propia estructura de la lista ocupaba unos 8,4 MB, mientras que el generador ocupaba sólo 200 bytes en nuestro sistema. La brecha real es aún mayor, ya que getsizeof no cuenta los objetos enteros dentro de la lista. El tamaño del generador también permanece igual para mil millones de artículos, ya que sólo almacena su estado actual y no sus resultados.

Sin embargo, existe una compensación. Una lista se puede reutilizar, indexar y medir con len(). Un generador no ofrece nada de esto. Si necesita acceso aleatorio o recorrerá varias veces una pequeña cantidad de datos, una lista es más sencilla. Consulte nuestra guía para Lista de Python, tupla y conjunto para obtener más información sobre esos tipos.

Expresiones generadoras

Para casos simples, no necesita una función. Una expresión generadora se parece a una lista de comprensión con corchetes en lugar de cuadrados:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Cuando una expresión generadora es el único argumento de una función, como en sum(), puede omitir los corchetes adicionales. Este es un hábito ordenado para totales de datos grandes, porque no se crea ninguna lista temporal.

Construya una canalización de datos

Aquí es donde realmente brillan los generadores. Se pueden encadenar pequeños generadores para que cada elemento fluya por cada paso, uno a la vez:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Cada paso realiza un pequeño trabajo y puede probarse por sí solo. En uso real, cambie la lista de muestra por un archivo abierto, porque los objetos del archivo se pueden leer línea por línea, como muestra nuestra guía para el manejo de archivos Python. Incluso un registro de varios gigabytes pasaría con muy poca memoria.

secuencias infinitas

Una lista no puede ser infinita, pero un generador sí, porque solo calcula el siguiente valor. Utilice itertools.islice para tomar tantos como necesite:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Sin embargo, tenga cuidado: llamar a list(fibonacci()) sin límite se ejecutará hasta que se acabe la memoria. El mismo patrón se adapta a los generadores de ID, los bucles de sondeo y los resultados de API paginados, donde se recupera la página siguiente sólo cuando se agota la actual.

rendimiento de y lotes

yield from pasa a otro iterable, ahorrándote un bucle anidado:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Un patrón muy práctico es dividir los datos en lotes de tamaño fijo, por ejemplo para insertar mil filas en una base de datos a la vez:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

El if batch final asegura que no se pierda un grupo sobrante más pequeño. Python 3.12 y posteriores también incluyen itertools.batched, que hace un trabajo similar.

enviar, cerrar y limpiar

Los generadores también pueden recibir valores. send() reanuda el generador y el valor se convierte en el resultado de la expresión yield. Primero debe llamar a next() una vez para comunicarse con el primer yield:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

La mayoría de la gente rara vez necesita esto. Una preocupación más común es la limpieza. Si se detiene antes, todavía se ejecuta un bloque finally cuando el generador está cerrado:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest usa esta misma idea: un dispositivo con yield ejecuta su limpieza después, como lo demuestra nuestro tutorial de pytest. Del mismo modo, el decorador contextmanager de la biblioteca estándar convierte un generador en un bloque with.

Generadores en clases.

Escribir un método __iter__ como generador es la forma más sencilla de hacer que su clase sea iterable. Una ventaja es que cada bucle obtiene un generador nuevo, por lo que el objeto se puede repetir una y otra vez:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Cuando usar un generador

Un generador no siempre es más rápido en general. Si termina usando todos los valores, el trabajo total es similar y la comprensión de una lista puede ser incluso más rápida para datos pequeños porque tiene menos gastos generales por elemento. Los principales beneficios son el uso de la memoria y la obtención de los primeros resultados antes.

Errores comunes

Reutilizar un generador agotado

Esto atrapa a casi todo el mundo en algún momento. Un generador recuerda que está terminado:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

La segunda llamada obtiene una lista vacía sin ningún error. Llame a la función nuevamente para obtener un nuevo generador o use el enfoque de clases que se muestra arriba.

Esperando que el código se ejecute inmediatamente

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Las comprobaciones de argumentos en la parte superior de un generador no se ejecutan hasta el primer next(), por lo que los errores pueden aparecer lejos de la llamada que los causó.

Otras trampas

• Llamar a len() o indexar. Los generadores no admiten ninguno de los dos y generan un TypeError.
• Cerrar un archivo demasiado pronto. Devolver un generador desde dentro de un bloque with puede significar que el archivo se cierra antes de que se lea cualquier línea. Coloque el yield dentro del bloque with.
• Envolviendo todo en list(). Eso desperdicia el beneficio de la memoria.
• Usar uno para datos pequeños. Una lista sencilla suele ser más clara.

Conclusión

Un generador es una función que puede pausarse. Esa única idea le brinda un bajo uso de memoria, secuencias interminables y canalizaciones limpias. Para ponerlo en práctica, busque un lugar en su código que cree una lista grande solo para recorrerla una vez y conviértalo en un generador. Luego intente encadenar dos pequeños generadores en un archivo de registro real.

Preguntas frecuentes

sigue aprendiendo