Generadores

Expresiones generadoras, funciones con yield, yield from y casos de uso prácticos.

Creado por

SebastianZ28

Valoración0 votos

-.-

functions

Expresiones generadoras

Una expresión generadora tiene la misma sintaxis que una list comprehension, pero usa paréntesis () en lugar de corchetes []. La diferencia es fundamental:

La lista calcula y almacena todos los elementos en memoria al crearse.
El generador almacena solo la receta (la expresión), y calcula cada elemento a medida que se pide.

Como los generadores son un caso especial de iteradores, solo pueden usarse una vez.

python

lst = [x**2 for x in range(5)]   # list comprehension — crea lista completa
gen = (x**2 for x in range(5))   # generator expression — calcula de a uno
 
print(type(lst))   # <class 'list'>
print(type(gen))   # <class 'generator'>
 
# next() funciona igual que en cualquier iterador
print(next(gen))   # 0
print(next(gen))   # 1
 
# Un generador solo se recorre UNA vez
for n in gen: print(n, end=' ')  # 4 9 16  (continua donde quedo next)
for n in gen: print(n, end=' ')  # (vacio — ya se agoto)

python

from sys import getsizeof
 
# Diferencia de memoria con un millon de elementos
gen = (x**2 for x in range(10**6))
lst = [x**2 for x in range(10**6)]
print(getsizeof(gen))   # 104 bytes — tamaño constante
print(getsizeof(lst))   # ~8 000 000 bytes
 
# if al final: FILTRA (algunos elementos no se generan)
solos_pares = (x for x in range(10) if x % 2 == 0)
for n in solos_pares: print(n, end=' ')  # 0 2 4 6 8

Cargando Quiz...

code

Funciones generadoras: yield

Una función generadora es una función que contiene la instrucción yield. A diferencia de return, yield pausa la función y entrega el valor — la próxima llamada a next() reanuda la ejecución desde donde quedó.

Regla clave: llamar a la función no ejecuta nada — retorna un objeto generador. El código dentro de la función solo corre cuando se piden valores con next() o un for.

python

def conteo_decreciente(n):
    print(f'Inicio: contando desde {n}')
    while n > 0:
        yield n          # pausa y entrega n
        n -= 1           # continua aqui en el proximo next()
 
g = conteo_decreciente(3)  # NO imprime nada — solo crea el generador
print(type(g))             # <class 'generator'>
 
print(next(g))  # imprime 'Inicio: contando desde 3', retorna 3

hub

yield from

yield from iterable delega la generación a otro iterable, produciendo todos sus elementos uno a uno — sin necesidad de un loop explícito. Es útil para componer generadores de forma limpia y modular.

python

# Sin yield from: necesitas un for explícito
def generador_manual():
    for x in range(5):
        yield x
 
# Con yield from: mas limpio, mismo resultado
def generador_simple():
    yield from range(5)
 
# Composición: encadenar múltiples fuentes
def generador_hijo():
    for i in range(3):

sync_alt

Corrutinas: enviar valores con send()

Hasta ahora el generador solo produce valores con yield. Pero un generador también puede recibir valores desde afuera con .send(valor): cuando escribes x = yield ..., la expresión yield devuelve lo que le envíen con send. Un generador usado así se llama corrutina.

Antes del primer send(valor) debes avanzar el generador hasta el primer yield, con next(g) (o g.send(None)). Si haces send con un valor antes de cebar, Python lanza TypeError: can't send non-None value to a just-started generator.

Hay que 'cebar' el generador

python

def acumulador():
    total = 0
    while True:
        x = yield total     # entrega 'total' y espera; x = lo que envie send()
        total += x
 
g = acumulador()
next(g)              # cebar: avanza hasta el primer yield (entrega 0)
print(g.send(5))     # x=5 -> total=5 -> 5

terminal

Generadores en la práctica

Los generadores son ideales cuando:

La secuencia es muy grande y no cabe cómodamente en memoria
Solo necesitas procesar los elementos de a uno (sin acceso aleatorio)
La secuencia es infinita o potencialmente infinita
Quieres componer transformaciones en pipeline sin crear listas intermedias

python

# Leer archivo grande línea a línea sin cargar todo en memoria
def cargar_archivo(path):
    with open(path, encoding='utf-8') as f:
        for line in f:   # 'for line in f' ya es un generador nativo
            yield line
 
# Máximo acumulativo: yield el máximo visto hasta ahora
def maximo_acumulativo(valores):
    max_ = float('-inf')