Sie haben gelernt, eigene **Context Manager** zu erstellen und diese verschachtelt oder mehrfach zu verwenden. Nun sollen Sie benutzerdefinierte Context Manager entwerfen und implementieren, die sowohl einzeln als auch gemeinsam funktionieren und dabei sicherstellen, dass Ressourcen korrekt übernommen und freigegeben werden. Achten Sie darauf, wie Ausnahmen behandelt werden und wie die Reihenfolge des Eintritts und Austritts von Context Managern das Programmverhalten beeinflusst.


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

class TestTask(unittest.TestCase):
    def test_manager_a_enter_exit(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            a = user_code.ManagerA()
            a.__enter__()
            a.__exit__(None, None, None)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "entering managera" in output and "exiting managera" in output,
            "ManagerA prints enter and exit messages",
            f"ManagerA missing enter/exit messages: {output}"
        )

    def test_manager_b_enter_exit(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            b = user_code.ManagerB()
            b.__enter__()
            b.__exit__(None, None, None)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "entering managerb" in output and "exiting managerb" in output,
            "ManagerB prints enter and exit messages",
            f"ManagerB missing enter/exit messages: {output}"
        )

    def test_nesting_order(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            with user_code.ManagerA():
                with user_code.ManagerB():
                    pass
        output = normalize_text(f.getvalue())
        # Should be: Entering ManagerA, Entering ManagerB, Exiting ManagerB, Exiting ManagerA
        idx_enter_a = output.find("entering managera")
        idx_enter_b = output.find("entering managerb")
        idx_exit_b = output.find("exiting managerb")
        idx_exit_a = output.find("exiting managera")
        correct_order = (
            idx_enter_a != -1 and
            idx_enter_b != -1 and
            idx_exit_b != -1 and
            idx_exit_a != -1 and
            idx_enter_a < idx_enter_b < idx_exit_b < idx_exit_a
        )
        _dynamic_test(
            self,
            correct_order,
            "Nesting order is correct: ManagerA enters before ManagerB, ManagerB exits before ManagerA",
            f"Incorrect nesting order: {output}"
        )

    def test_multiple_with_order(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            with user_code.ManagerA(), user_code.ManagerB():
                pass
        output = normalize_text(f.getvalue())
        # Should be: Entering ManagerA, Entering ManagerB, Exiting ManagerB, Exiting ManagerA
        idx_enter_a = output.find("entering managera")
        idx_enter_b = output.find("entering managerb")
        idx_exit_b = output.find("exiting managerb")
        idx_exit_a = output.find("exiting managera")
        correct_order = (
            idx_enter_a != -1 and
            idx_enter_b != -1 and
            idx_exit_b != -1 and
            idx_exit_a != -1 and
            idx_enter_a < idx_enter_b < idx_exit_b < idx_exit_a
        )
        _dynamic_test(
            self,
            correct_order,
            "Multiple context manager order is correct: ManagerA enters before ManagerB, ManagerB exits before ManagerA",
            f"Incorrect order for multiple context managers: {output}"
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Sie werden praktische Fähigkeiten in Pythons Modulen und Importen für effizientes Code-Management erwerben. Beherrschen Sie fortgeschrittene Fehlerbehandlungstechniken für zuverlässigere Anwendungen, automatisieren Sie Dateioperationen mit Dateiverwaltung und lernen Sie robuste Teststrategien mit Pytest und Unittest, um die Integrität Ihres Codes sicherzustellen.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Challenge: Stapeln von Kontextmanagern

Lösung