Summary  
This chapter covers how to create and use a custom iterable range by defining start, end, and step values and implementing the iterator protocol (or using a generator) to loop through numeric sequences.

General domain of usage  
Data processing


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

class TestTask(unittest.TestCase):
    def test_odds_in_range(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(3, 11)
        result = list(odds)
        expected = [3, 5, 7, 9]
        _dynamic_test(
            self,
            result == expected,
            f"Yields correct odd numbers from 3 (inclusive) to 11 (exclusive): {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_first_odd_is_start_if_odd(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(7, 15)
        result = list(odds)
        expected = [7, 9, 11, 13]
        _dynamic_test(
            self,
            result and result[0] == 7,
            "First yielded number is start if start is odd.",
            f"First yielded number should be 7, got {result[0] if result else None}",
        )

    def test_first_odd_is_start_plus_one_if_even(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(8, 15)
        result = list(odds)
        expected = [9, 11, 13]
        _dynamic_test(
            self,
            result == expected,
            "First yielded number is start+1 if start is even.",
            f"Expected {expected}, got {result}",
        )

    def test_stop_iteration(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(3, 5)
        it = iter(odds)
        next_val = next(it)
        _dynamic_test(
            self,
            next_val == 3,
            "First call to next yields 3.",
            f"Expected 3, got {next_val}",
        )
        raised = False
        try:
            next(it)
        except StopIteration:
            raised = True
        _dynamic_test(
            self,
            raised,
            "StopIteration is raised after all odds are yielded.",
            "StopIteration was not raised when expected.",
        )

    def test_negative_range(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(-5, 2)
        result = list(odds)
        expected = [-5, -3, -1, 1]
        _dynamic_test(
            self,
            result == expected,
            "Works for negative start and stop.",
            f"Expected {expected}, got {result}",
        )

    def test_empty_range(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(4, 5)
        result = list(odds)
        expected = []
        _dynamic_test(
            self,
            result == expected,
            "Yields no values if no odds in range.",
            f"Expected {expected}, got {result}",
        )

    def test_no_odds_in_range(self):
        import user_code
        importlib.reload(user_code)
        odds = user_code.OddRange(2, 4)
        result = list(odds)
        expected = [3]
        _dynamic_test(
            self,
            result == expected,
            "Yields only odd numbers in the range.",
            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: Iterating Over a Custom Range

解答