Summary  
This chapter covers implementing separate generator functions for producing sequences of values and chaining them into a single sequence using the `yield from` statement for delegation.

General domain of usage  
Data processing pipelines

In this task, you will deepen your understanding of generator delegation and chaining by implementing two separate generator functions: one that yields a sequence of numbers and another that yields the squares of those numbers. You will then use the `yield from` statement to chain these generators, producing a single combined sequence that first yields all numbers and then their squares. This exercise builds on your knowledge of generator functions and the use of `yield from` for delegation, as introduced in the previous chapter.


import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_number_generator(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.number_generator(5)
        result = list(gen)
        expected = [1, 2, 3, 4, 5]
        _dynamic_test(
            self,
            result == expected,
            "number_generator yields numbers from 1 to n in order",
            f"Expected {expected}, got {result}"
        )

    def test_square_generator(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.square_generator(4)
        result = list(gen)
        expected = [1, 4, 9, 16]
        _dynamic_test(
            self,
            result == expected,
            "square_generator yields squares from 1 to n in order",
            f"Expected {expected}, got {result}"
        )

    def test_chained_generator(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.chained_generator(3)
        result = list(gen)
        expected = [1, 2, 3, 1, 4, 9]
        _dynamic_test(
            self,
            result == expected,
            "chained_generator yields numbers then their squares in order",
            f"Expected {expected}, got {result}"
        )

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

Master the art of efficient iteration in Python by learning about iterators and generators. This course covers the creation, use, and advanced techniques of generators and iterators, with hands-on tasks and conceptual quizzes to reinforce your understanding.

Explore the fundamentals of Python's iteration protocol and learn how to create and use custom iterators.

Learn how to use generator functions and expressions for efficient, lazy iteration.

Master advanced generator features such as delegation, state management, and practical applications.

Challenge: Chained Generators

Solution

Challenge: Chained Generators

Solution