Summary  
This chapter covers generator expressions as a lazy, memory-efficient way to filter and process sequence items one at a time based on a condition.

General domain of usage  
Large-scale data processing

Generator expressions provide a **concise** and **memory-efficient** way to filter and process sequences in Python. Unlike list comprehensions, generator expressions do not build the entire result in memory; instead, they yield items one at a time as you iterate over them. This is especially useful when you want to work with large datasets or when you only need to process a subset of the data matching a particular condition. Filtering for specific values, such as even numbers, is a common use case for generator expressions. You will now apply this concept in a practical coding task.


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

class TestTask(unittest.TestCase):
    def test_returns_generator(self):
        import user_code
        importlib.reload(user_code)
        nums = [2, 4, 6]
        result = user_code.even_numbers(nums)
        from types import GeneratorType
        _dynamic_test(
            self,
            hasattr(result, '__iter__') and not isinstance(result, list),
            "Function returns a generator object.",
            f"Function did not return a generator object. Got type: {type(result)}",
        )

    def test_yields_all_even_numbers(self):
        import user_code
        importlib.reload(user_code)
        nums = [1, 2, 3, 4, 5, 6]
        result = list(user_code.even_numbers(nums))
        expected = [2, 4, 6]
        _dynamic_test(
            self,
            result == expected,
            "All even numbers are yielded in order.",
            f"Expected {expected}, got {result}",
        )

    def test_no_odd_numbers_yielded(self):
        import user_code
        importlib.reload(user_code)
        nums = [1, 3, 5, 7]
        result = list(user_code.even_numbers(nums))
        _dynamic_test(
            self,
            all(n % 2 == 0 for n in result) and result == [],
            "No odd numbers are yielded if none are even.",
            f"Expected empty list, got {result}",
        )

    def test_empty_input(self):
        import user_code
        importlib.reload(user_code)
        nums = []
        result = list(user_code.even_numbers(nums))
        _dynamic_test(
            self,
            result == [],
            "Function works correctly with empty input.",
            f"Expected empty list, got {result}",
        )

    def test_only_even_numbers(self):
        import user_code
        importlib.reload(user_code)
        nums = [2, 4, 8, 10]
        result = list(user_code.even_numbers(nums))
        expected = [2, 4, 8, 10]
        _dynamic_test(
            self,
            result == expected,
            "All even numbers are yielded and order is preserved.",
            f"Expected {expected}, got {result}",
        )

    def test_order_preserved(self):
        import user_code
        importlib.reload(user_code)
        nums = [8, 2, 4, 10, 3, 1, 5]
        result = list(user_code.even_numbers(nums))
        expected = [8, 2, 4, 10]
        _dynamic_test(
            self,
            result == expected,
            "Generator yields even numbers in original 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: Filtering with Generator Expressions

Oplossing

Challenge: Filtering with Generator Expressions

Oplossing