Summary  
This chapter covers generator functions that use `yield` to pause and resume execution for memory-efficient, on-the-fly value production and support iteration via `next()` or `for` loops.

General domain of usage  
data stream processing

A **generator function** is a special type of function that uses the `yield` keyword instead of `return` to generate a sequence of values. When a generator function is called, it returns an iterator object, which can be iterated over to retrieve values one at a time.

Definition

The main advantage of generator functions is their **memory efficiency**. Instead of generating the entire sequence upfront and storing it in memory, generators produce values **on-the-fly** as they are needed.

## How `yield` Works

Unlike `return`, which exits the function entirely, `yield` **pauses** the function and saves its state. The next time `next()` is called, the generator resumes from exactly where it left off:


def count_up(start, stop):
    while start <= stop:
        yield start  # Pause and return the current value
        start += 1   # Resume from here on the next call

counter = count_up(1, 3)

print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3

You can also iterate over a generator using a `for` loop – it automatically calls `next()` until the generator is exhausted:

def count_up(start, stop):
    while start <= stop:
        yield start
        start += 1

for value in count_up(1, 5):
    print(value)  # 1, 2, 3, 4, 5

Once a generator is exhausted (no more values to yield), calling `next()` on it will raise a `StopIteration` error. A `for` loop handles this automatically.

Note

import unittest
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestEvenNumbers(unittest.TestCase):

    def test_even_numbers_is_generator(self):
        import user_code
        import types
        try:
            result = user_code.even_numbers(1, 10)
            condition = isinstance(result, types.GeneratorType)
            failure_message = "Expected `even_numbers` to return a generator object."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` function returns a generator object.", failure_message)

    def test_even_numbers_correct_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            expected = [2, 4, 6, 8, 10]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator yields `[2, 4, 6, 8, 10]` for range 1 to 10.", failure_message)

    def test_even_numbers_no_odd_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            condition = all(n % 2 == 0 for n in result)
            failure_message = f"Expected only even numbers, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` generator yields only even numbers.", failure_message)

    def test_even_numbers_different_range(self):
        import user_code
        try:
            result = list(user_code.even_numbers(5, 20))
            expected = [6, 8, 10, 12, 14, 16, 18, 20]
            condition = result == expected
            failure_message = f"Expected `{expected}` for range 5 to 20, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator correctly handles the range 5 to 20.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Generator Functions

How `yield` Works

Solution

Generator Functions

How yield Works

Solution

How `yield` Works