Summary  
This chapter shows how to implement a custom iterator by defining `__iter__` and `__next__` methods to generate a countdown sequence from a start value down to zero.

General domain of usage  
Sequence generation


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_countdown_sequence(self):
        import user_code
        importlib.reload(user_code)
        Countdown = getattr(user_code, 'Countdown', None)
        _dynamic_test(
            self,
            Countdown is not None,
            "Countdown class is defined",
            "Countdown class is not defined",
        )
        c = Countdown(5)
        result = [x for x in c]
        expected = [5, 4, 3, 2, 1, 0]
        _dynamic_test(
            self,
            result == expected,
            f"Countdown yields correct sequence {expected}",
            f"Countdown yields {result}, expected {expected}",
        )

    def test_countdown_stops_after_zero(self):
        import user_code
        importlib.reload(user_code)
        Countdown = getattr(user_code, 'Countdown', None)
        c = Countdown(2)
        it = iter(c)
        values = []
        try:
            while True:
                values.append(next(it))
        except StopIteration:
            pass
        _dynamic_test(
            self,
            values == [2, 1, 0],
            "Countdown yields down to zero and then stops",
            f"Countdown yields {values}, expected [2, 1, 0]",
        )
        with self.assertRaises(StopIteration):
            next(it)

    def test_countdown_zero_start(self):
        import user_code
        importlib.reload(user_code)
        Countdown = getattr(user_code, 'Countdown', None)
        c = Countdown(0)
        values = [x for x in c]
        _dynamic_test(
            self,
            values == [0],
            "Countdown yields [0] when started at zero",
            f"Countdown yields {values}, expected [0]",
        )

    def test_multiple_iterators(self):
        import user_code
        importlib.reload(user_code)
        Countdown = getattr(user_code, 'Countdown', None)
        c1 = Countdown(1)
        c2 = Countdown(3)
        res1 = [x for x in c1]
        res2 = [x for x in c2]
        _dynamic_test(
            self,
            res1 == [1, 0] and res2 == [3, 2, 1, 0],
            "Multiple Countdown instances work independently",
            f"Countdown yields {res1} and {res2}, expected [1, 0] and [3, 2, 1, 0]",
        )

    def test_iter_returns_self(self):
        import user_code
        importlib.reload(user_code)
        Countdown = getattr(user_code, 'Countdown', None)
        c = Countdown(4)
        _dynamic_test(
            self,
            iter(c) is c,
            "__iter__ returns self",
            "__iter__ does not return self",
        )

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: Create a Countdown Iterator

解答