Python Academy · Lección

yield from y delegación

Combine generadores

yield from y delegación es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

El problema que resuelve yield from

Cuando un generador quiere producir todos los valores de otro iterable, puede escribir un bucle manual. yield from hace lo mismo en una sola línea.

def manual():
    for x in [1, 2, 3]:
        yield x

print(list(manual()))

Introducción a yield from

yield from iterable delega en ese iterable y produce cada uno de sus valores sucesivamente. Es más breve y claro que un bucle de reenvío.

def delegate():
    yield from [1, 2, 3]

print(list(delegate()))

Combinar varias fuentes

Puede encadenar varias instrucciones yield from para concatenar secuencias de forma perezosa.

def chained():
    yield from 'ab'
    yield from [1, 2]
    yield from range(2)

print(list(chained()))

Delegar en otro generador

El iterable delegado puede ser a su vez un generador, lo que permite combinar generadores para crear otros más grandes.

def evens(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

def report(n):
    print('evens:')
    yield from evens(n)

print(list(report(6)))

Aplanar listas anidadas

Un uso clásico de yield from es el aplanado recursivo: un generador que delega en sí mismo para procesar las sublistas.

def flatten(items):
    for item in items:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

print(list(flatten([1, [2, [3, 4]], 5])))

yield from frente a un bucle

Las dos versiones siguientes producen la misma salida. Se prefiere yield from por su legibilidad y porque también reenvía funciones avanzadas, como el envío de valores y los resultados devueltos.

def with_loop(src):
    for x in src:
        yield x

def with_yield_from(src):
    yield from src

print(list(with_loop(range(3))))
print(list(with_yield_from(range(3))))

Capturar el valor devuelto por un subgenerador

Cuando un generador delegado devuelve un valor con return, yield from se evalúa como ese valor. Esto permite que los subgeneradores comuniquen un resultado.

def counter(n):
    count = 0
    for i in range(n):
        yield i
        count += 1
    return count

def driver():
    total = yield from counter(3)
    print('subgen yielded', total, 'items')

list(driver())

Crear una canalización

La delegación facilita dividir una canalización en etapas con nombre y combinarlas.

def source():
    yield from range(5)

def only_odd(src):
    for x in src:
        if x % 2 == 1:
            yield x

def pipeline():
    yield from only_odd(source())

print(list(pipeline()))

Delegar en cualquier iterable

yield from funciona con cualquier iterable, no solo con generadores: listas, tuplas, conjuntos, cadenas, claves de diccionario y mucho más.

def mixed():
    yield from {1, 2, 3}
    yield from ('a', 'b')

result = list(mixed())
print(sorted(str(x) for x in result))

Combinar generadores en orden

Puede crear un generador que recorra varias fuentes secuencialmente, lo que resulta útil para unir flujos.

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

print(list(concat([1, 2], [3], [4, 5])))

La legibilidad importa

Para datos profundamente anidados o con forma de árbol, yield from mantiene breves los generadores recursivos y deja clara su intención.

def walk(tree):
    yield tree['name']
    for child in tree.get('children', []):
        yield from walk(child)

tree = {'name': 'root', 'children': [
    {'name': 'a'},
    {'name': 'b', 'children': [{'name': 'c'}]}
]}
print(list(walk(tree)))

Comprobación rápida

Compruebe su comprensión de yield from.

Resumen

Ha aprendido sobre yield from y la delegación:

Reenvía todos los valores de un iterable interno.
Permite combinar generadores y realizar aplanados recursivos.
Captura el valor devuelto por el subgenerador.
Es más claro que un bucle manual de reenvío.

Siguiente curso: concurrencia con threading y multiprocessing.

Preguntas frecuentes

¿La lección «yield from y delegación» es gratis?

Sí — el texto completo de «yield from y delegación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «yield from y delegación»?

Combine generadores Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «yield from y delegación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy