3.6. Coroutines Basics and Sending Values to Generators

Generators can also receive values, allowing two-way communication. This feature enables coroutines — functions that can pause and resume with data exchange.

Coroutines are a special kind of function that can pause their execution and then resume later. Unlike standard functions which run from start to finish, coroutines can yield control back to the caller, allowing them to process other tasks or send values back into the coroutine. This creates a two-way communication channel, enhancing the ability to manage and process data.

Think of a coroutine like a conversation between friends where one person can pause to listen to the other before continuing speaking. In the same way, coroutines can pause their execution to receive input from the outside.

def accumulator():
    total = 0
    while True:
        value = yield total  # Yield total, then wait for value sent in
        if value is None:
            break
        total += value
acc = accumulator()
print(next(acc))  # Start the generator, outputs 0
print(acc.send(10))  # Send 10, output 10
print(acc.send(5))  # Send 5, output 15
acc.send(None)  # Stop the generator

In this example, we define a generator function called accumulator, which maintains a running total of numbers sent to it. Initially, it yields a total of 0. The next(acc) starts the generator, and then we can send values to it using acc.send(value). When we send the value 10, it updates the total to 10, and sending 5 further updates it to 15. Finally, we stop the generator by sending None.

Imagine a bank teller who accumulates deposits as customers come in. When you walk in and request your balance (the initial next(acc)), the teller informs you that you have 0 in your account. When you deposit 10, the teller updates the balance to 10, and so on. If you say 'stop' (sending None), the teller closes the account.

Explanation:

• yield returns a value and pauses.
• send(value) resumes execution and sends value to the paused generator.
• next(gen) is equivalent to gen.send(None) and is used to start or advance generators.

yield is crucial as it allows the generator to output a value while keeping its state intact. The function can pause and wait for further input. Meanwhile, the send(value) function, when called, resumes the coroutine at the point where it yielded, effectively allowing external data to influence the ongoing computation. The next(gen) function is functionally similar to sending None, which is often used to step through the generator.

Think of yield as a student raising their hand to ask a question. The teacher (or the calling function) responds, and the student can then proceed with their lesson once they receive an answer. Each send is like the student participating in the class discussions, while next allows the student to simply move to the next topic.

--