Python yield from

Intermediate

Python's yield from expression lets one generator delegate to another iterable. Instead of writing a loop just to pass each value along, the current generator can hand that job to the delegated iterable and continue when delegation ends.

Delegate values to another iterable

The expression yield from iterable yields the values produced by that iterable to the caller of the current generator.

1
2
3
4

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

print(list(countdown()))

The delegated object can be any iterable

The expression after yield from must be iterable. That can be a list, tuple, string, or another iterator or generator.

1
2
3
4

def letters():
    yield from "ABC"

print(list(letters()))

Continue after delegation finishes

When the delegated iterable is exhausted, the current generator continues with the next statement after yield from. This makes it easy to build one generator from several stages.

1
2
3
4
5

def report():
    yield from ["queued", "running"]
    yield "finished"

print(list(report()))

A subgenerator can return a value

When the delegated object is a generator that ends with return value, the yield from expression itself produces that value. The surrounding generator can capture it with ordinary assignment.

1
2
3
4
5
6
7
8
9

def child():
    yield "step"
    return "done"

def parent():
    result = yield from child()
    print(f"child result: {result}")

print(list(parent()))

Delegate through another generator

Delegation can form layers. Each generator can hand its work to another generator without manually repeating its loop.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def source():
    yield from [10, 20, 30]

def middle():
    yield from source()

def outer():
    yield from middle()

print(list(outer()))

Why use yield from?

Use yield from when one generator's job is to expose another iterable's sequence as part of its own sequence. It makes delegation explicit and leaves the current generator free to add more values before or after the delegated work.

1
2
3
4
5
6
7

def sections():
    yield "intro"
    yield from ["body-1", "body-2"]
    yield "summary"

for section in sections():
    print(section)

yield from is not the same as yielding the iterable

A plain yield iterable yields the iterable object itself. yield from iterable instead delegates iteration so the iterable's values are produced one by one.

1
2
3
4
5
6
7
8

def whole():
    yield [1, 2, 3]

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

print(list(whole()))
print(list(parts()))

Keep the delegation boundary simple

Start with ordinary iteration and simple generator composition. Advanced generator communication and asynchronous delegation are separate topics; do not mix them into a first yield from lesson.