3.3.1. What is a Generator?

A generator is a special type of iterator defined with a function that yields values one at a time, suspending its state between yields. Generators simplify creating iterators without needing classes.

A generator is a unique kind of iterator that you create using a function. Instead of returning all values at once, it provides each value one at a time when asked. When it yields a value, it saves its state, which means it can continue from where it left off the next time it's called. This eliminates the need to write complex class-based iterators, making the code simpler and easier to understand.

Think of a generator like a vending machine. Instead of producing all drinks at once (like a standard function), it dispenses one drink at a time when you make a selection. Once it gives you a drink (yields a value), it pauses, waiting for your next request while remembering how many drinks it has left.

Use the yield keyword inside a function to define a generator.

def count_up_to(maximum):
    count = 1
    while count <= maximum:
        yield count
        count += 1

For example:

for num in count_up_to(5):
    print(num)

Output: 1 2 3 4 5

To create a generator function, you use the yield keyword in the body of the function. The example function count_up_to(maximum) counts from 1 to the specified maximum number. When called, it returns a generator that provides each number one at a time until the maximum is reached. Each invocation of next() on the generator advances it to the next yield, allowing you to retrieve numbers sequentially.

Imagine you're teaching a child to count. Instead of handing them all the numbers at once, you show them one number at a time, allowing them to process and remember each number before showing the next. This approach, just like a generator, makes it easier for the child to learn without feeling overwhelmed.

● When the generator function is called, it returns a generator object, but no code runs yet. ● Each call to next() resumes execution until the next yield returns a value. ● The function’s local state is saved between yields.

When you call a generator function, it doesn’t start executing right away; instead, it returns a generator object. The actual code runs only when you call next() on the generator. Each next() call resumes execution until it reaches the next yield, at which point it provides a value back to the caller and pauses again. This process continues, with the function's local variables and their states retained between calls, allowing it to pick up right where it left off.

Consider a novel you're reading. Each time you pick it up, you open it to the last page you read, continuing from there. You're not starting over from the beginning; instead, you are progressing through the book one chapter at a time. Similarly, a generator retains the previous state, allowing you to continue working with it one step at a time.

● Memory efficient: Values are produced on demand, not stored in memory. ● Lazy evaluation: They generate values only when requested. ● Simplify iterator code: No need for iter() or next() methods manually.

Generators have several significant advantages. First, they're memory efficient because they produce items only when they're needed, meaning you don't have to store all the values in memory at once. This is particularly useful for large datasets. Second, this 'lazy evaluation' allows generating values at the moment they're requested, saving on processing power. Lastly, using generators simplifies the code by alleviating the need to explicitly use methods like __iter__() or __next__(), which are essential in traditional iterator classes.

Imagine if you had a library that only brought in books as guests requested them instead of keeping every book on hand all the time. This not only saves space but also means that the library's resources are used more efficiently, similar to how generators operate by producing items on demand.

--