Summary  
This chapter explains how to implement an infinite sequence generator using lazy evaluation (for example, generator functions or iterators) to produce an unbounded series of values on demand.  

General domain of usage  
Mathematical computations


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

class TestTask(unittest.TestCase):
    def test_first_multiple(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.infinite_multiples(7)
        first = next(gen)
        _dynamic_test(
            self,
            first == 7,
            "First multiple equals k (7)",
            f"Expected first multiple 7, got {first}",
        )

    def test_subsequent_multiples(self):
        import user_code
        importlib.reload(user_code)
        k = 4
        gen = user_code.infinite_multiples(k)
        prev = next(gen)
        passed = True
        for _ in range(1, 10):
            curr = next(gen)
            if curr - prev != k:
                passed = False
                break
            prev = curr
        _dynamic_test(
            self,
            passed,
            "Each value is exactly k greater than the previous one (k=4)",
            "Subsequent multiples are not correct (should increase by k)",
        )

    def test_no_stop_iteration(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.infinite_multiples(2)
        passed = True
        try:
            for _ in range(1000):
                next(gen)
        except StopIteration:
            passed = False
        _dynamic_test(
            self,
            passed,
            "Generator yields values indefinitely (no StopIteration)",
            "Generator stopped unexpectedly (StopIteration raised)",
        )

    def test_negative_k(self):
        import user_code
        importlib.reload(user_code)
        k = -5
        gen = user_code.infinite_multiples(k)
        values = [next(gen) for _ in range(6)]
        expected = [-5, -10, -15, -20, -25, -30]
        _dynamic_test(
            self,
            values == expected,
            "Generator works for negative k",
            f"Expected {expected}, got {values}",
        )

    def test_zero_k(self):
        import user_code
        importlib.reload(user_code)
        gen = user_code.infinite_multiples(0)
        values = [next(gen) for _ in range(5)]
        expected = [0, 0, 0, 0, 0]
        _dynamic_test(
            self,
            values == expected,
            "Generator yields zeros indefinitely when k=0",
            f"Expected {expected}, got {values}",
        )

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: Infinite Sequence Generator

Lösung