Generadores de Python: Cómo procesar conjuntos de datos masivos sin colapsar tu computadora

El muro de ‘memoria llena’

¿Alguna vez has intentado abrir un archivo CSV enorme, solo para ver tu computadora convertirse en un pisapapeles muy caro? El cursor se congela, el ventilador zumba como un motor a reacción, y finalmente Python lanza ese temido mensaje: MemoryError.

Esto es lo que ocurre por debajo. Cuando creas una lista estándar de Python, le estás pidiendo a tu computadora que construya todo el producto terminado y lo almacene en tu RAM. Es como cocinar una comida para 1,000 personas y poner todos los platos en tu encimera de cocina al mismo tiempo. A menos que tengas una cocina enorme, te quedarás sin espacio.

Ahora veamos qué ocurre cuando creamos una lista con 50 millones de números.

import sys

try:
    # Creating a list of 50 million integers
    massive_list = [i for i in range(50000000)]
    print(f"List size: {sys.getsizeof(massive_list) / (1024**2):.2f} MB")
except MemoryError:
    print("Your computer just ran out of RAM!")

En una laptop estándar, esta lista podría ocupar más de 400 MB de RAM solo para la estructura misma — sin contar los enteros reales. Escala esto a 500 millones, o intenta cargar un archivo de registro de 10GB, y tu sistema se colapsa. Ese es el muro de ‘Memoria Llena’.

En lugar de una lista (la comida terminada), necesitamos una receta — un generador. Un generador no retiene los datos. Retiene las instrucciones para generar los datos, una pieza a la vez.

Conoce la palabra clave ‘yield’: el botón de pausa de tu código

En una función normal, usas return. Cuando Python llega a return, la función termina: entrega el resultado y limpia su memoria. yield funciona de manera diferente. Piensa en ello como un botón de ‘pausa’.

Cuando una función usa yield, se convierte en un generador. Llámala, y nada se ejecutará todavía. Solo se queda en espera. Pide un valor, y se ejecuta hasta que llega a yield, te entrega ese único valor, y luego se queda justo ahí, esperando la siguiente petición.

La parte complicada: la función ‘recuerda’ su estado. Comparemos una función estándar con un generador.

def get_numbers_list(n):
    result = []
    for i in range(n):
        result.append(i)
    return result

def get_numbers_generator(n):
    for i in range(n):
        yield i

# The list function builds everything first
numbers = get_numbers_list(5)
print(f"List: {numbers}")

# The generator function just waits
gen = get_numbers_generator(5)
print(f"Generator object: {gen}")

# We get values one by one
print(f"First value: {next(gen)}")
print(f"Second value: {next(gen)}")

Lo que esto significa en la práctica: la función generadora solo necesita suficiente memoria para contener un elemento a la vez. La función de lista necesita suficiente memoria para todos ellos.

La expresión generadora: un superpoder en una línea

Probablemente conozcas las comprensiones de lista como [x for x in data]. Son útiles, pero “eager”: la lista completa se construye de inmediato.

Sin embargo, cambia esos corchetes [] por paréntesis () y obtendrás un generador. Eso es una expresión generadora.

import sys

# A list comprehension
list_comp = [i for i in range(1000000)]

# A generator expression
gen_exp = (i for i in range(1000000))

print(f"List size: {sys.getsizeof(list_comp)} bytes")
print(f"Generator size: {sys.getsizeof(gen_exp)} bytes")

En mi máquina, la lista ocupa 8,448,728 bytes. ¿El generador? 112 bytes.

Diez elementos o diez mil millones: el generador se mantiene en 112 bytes. ¿Por qué? Porque no está almacenando los números. Está almacenando la lógica de cómo contar hasta un millón.

Datos del mundo real: streaming de un CSV masivo

Apliquemos esto a un problema real de ciencia de datos. Digamos que tienes un CSV con 10 millones de filas de datos de ventas, y quieres solo las filas donde ‘price’ es mayor a $100. pandas.read_csv() carga todo el archivo en la RAM.

Un generador te permite procesar el archivo como un flujo en su lugar. El uso de RAM se mantiene constante, incluso con 100GB.

import csv

def stream_expensive_items(filename):
    with open(filename, mode='r') as f:
        # csv.DictReader is a generator! It reads one line at a time.
        reader = csv.DictReader(f)
        for row in reader:
            if float(row['price']) > 100:
                yield row

# Let's imagine 'huge_data.csv' exists
# expensive_items = stream_expensive_items('huge_data.csv')
# for item in expensive_items:
#     print(item)

La idea es esta: abrimos el archivo, tomamos una fila, verificamos el precio. La descartamos si es barata; la pasamos si es cara. Luego, la siguiente fila. Nunca más de una fila en memoria a la vez. El resultado: puedes procesar archivos más grandes que tu RAM sin ralentizar tu computadora.

El problema: cuando los generadores no son la solución

Los generadores suenan como magia, pero tienen dos limitaciones reales.

Primero, son de un solo uso. Recorre un generador con un bucle y queda agotado. Piensa en un rollo de película: una vez que lo has revelado, no puedes reproducirlo de nuevo sin empezar desde cero y releer la fuente.

Segundo, no hay indexación. ¿Quieres el elemento 500? El generador tiene que ejecutar la lógica de los primeros 499 para llegar ahí.

gen = (i for i in range(3))

# First pass
for val in gen:
    print(val)

# Second pass - this will print NOTHING
for val in gen:
    print("This won't run!")

try:
    print(gen[0])
except TypeError as e:
    print(f"Error: {e}")

Si necesitas ordenar, mezclar o acceder a filas específicas múltiples veces, quédate con una lista (o un DataFrame de Pandas). Pero para limpieza, filtrado o agregación, los generadores son difíciles de superar.

import csv
import logging

logger = logging.getLogger(__name__)

def stream_rows(filename):
    with open(filename) as f:
        reader = csv.DictReader(f)
        for row in reader:
            yield row

def run_inference(filename, model):
    rows = stream_rows(filename)

    # Production monitoring: log total row count
    total = sum(1 for _ in rows)
    logger.info(f"Processing {total} rows from {filename}")

    # Score every row
    predictions = [model.predict(row) for row in rows]
    return predictions