Summary  
This chapter demonstrates how to implement a stateful generator that maintains internal state across iterations to compute a running average of input values.

General domain of usage  
Streaming data processing


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

class TestTask(unittest.TestCase):
    def test_initial_yield_none(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.running_average()
        result = next(gen)
        _dynamic_test(
            self,
            result is None,
            "Generator yields None on initial next() call",
            f"Expected None on initial next(), got {result}",
        )

    def test_first_send(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.running_average()
        next(gen)
        result = gen.send(10)
        _dynamic_test(
            self,
            isinstance(result, float) and result == 10.0,
            "Generator yields correct average after first value",
            f"Expected 10.0, got {result}",
        )

    def test_multiple_sends(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.running_average()
        next(gen)
        result1 = gen.send(10)
        result2 = gen.send(20)
        result3 = gen.send(30)
        _dynamic_test(
            self,
            result1 == 10.0 and result2 == 15.0 and result3 == 20.0,
            "Generator yields correct averages after multiple sends",
            f"Expected 10.0, 15.0, 20.0, got {result1}, {result2}, {result3}",
        )

    def test_running_total_and_count(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.running_average()
        next(gen)
        values = [4, 8, 12, 16]
        expected_averages = [4.0, 6.0, 8.0, 10.0]
        for i, val in enumerate(values):
            avg = gen.send(val)
            _dynamic_test(
                self,
                avg == expected_averages[i],
                f"Correct running average after sending {val}",
                f"Expected {expected_averages[i]} after {val}, got {avg}",
            )

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: Stateful Running Average Generator

Oplossing

Challenge: Stateful Running Average Generator

Oplossing