Python Generator Control with send(), throw(), and close()

Advanced

A generator is normally advanced by next() or a for loop. Python also lets the caller control a paused generator explicitly: send() places a value into the paused yield expression, throw() raises an exception there, and close() asks the generator to finish.

Start before sending a value

A newly created generator has not reached a yield expression yet. Its first send() must pass None because there is no paused yield ready to receive another value. The usual equivalent is next(generator).

Send a value into a paused yield

When a generator is paused at value = yield the next send(value) resumes it and makes the current yield expression evaluate to that value. The generator then continues until it yields again or finishes.

next() and send(None) resume in the same way

Both next(generator) and send(None) resume a suspended generator without supplying a useful value to its current yield expression. Use send(value) when the generator is designed to receive information from its caller.

Inject an exception with throw()

throw(exception) resumes the generator by raising that exception at the paused yield. The generator can catch it with ordinary try / except logic and choose what to do next.

An uncaught thrown exception reaches the caller

If the generator does not catch the exception introduced by throw() then the exception leaves the generator and is raised to its caller. throw() changes where the exception is raised; it does not create a second exception-handling system.

close() asks a suspended generator to finish

close() asks a suspended generator to terminate. A finally block still runs during that termination, which makes it a natural place for cleanup when the caller stops iterating early.

Control methods operate on a suspended generator

The control methods in this lesson are operations on generator state. A generator method cannot safely re-enter the same generator while it is already running; Python raises ValueError for that case. In normal code, make each control call only after the previous call has returned or raised.

Quick check

def worker():
    received = yield "ready"

generator = worker()
next(generator)
generator.?("yes")