What Does yield Do in Python?

yield produces one value and pauses the function there, keeping its state so it can be resumed.

def countdown(start):
    while start > 0:
        yield start
        start -= 1


gen = countdown(3)
print(next(gen))              # 3
print(next(gen))              # 2
print(next(gen))              # 1
try:
    next(gen)
except StopIteration:
    print("the generator is exhausted")

The first call to next runs the function until the yield, produces 3 and suspends the function there. The second call resumes from that point — start still holds 3 — decrements it and yields 2. The state of the function is preserved between calls, which is the whole point.

The final call shows how the function ends. The while loop finishes, the function returns, and Python converts that into a StopIteration, which is the signal that the generator has no more values. A for loop catches it and stops cleanly.

The difference from return is that return ends the function and gives back a single value. yield gives back a value and keeps the function alive, ready to produce the next one. A function containing yield is a generator function, and calling it returns a generator object rather than running the body.

Two advanced details worth mentioning in an interview. yield from delegates iteration to another generator, forwarding its values — simpler and faster than looping over it manually. And yield is a two-way channel: the value sent into the generator by send() becomes the result of the yield expression, which is how coroutines are built on top of plain generators.

yield produces a value to the caller and suspends the function, keeping its local variables and its position in the code. When the caller asks for the next value, execution resumes exactly where it stopped. return, by contrast, ends the function immediately and hands back a single value, discarding all local state.

That difference is why a function containing yield is a different kind of object. Calling it does not run the body at all — you get back a generator object, and the body starts only when the first value is requested. That is the lazy behaviour, and it is what makes a generator cheap in memory no matter how many values it will eventually produce.

There is a second difference worth stating. return ends the function. yield does not; the generator is not finished until it either runs out of code or is closed. And when a generator function does finally return, that return value is turned into a StopIteration exception — which is how the for loop knows to stop.

The practical rules that follow. Use yield when you want to produce a sequence, especially one that is expensive or infinite. Use return when the function computes one answer. And when a generator delegates to another generator, use yield from rather than a manual for loop over it — it is shorter, it is faster, and it forwards the two-way communication correctly.