Combining multiple decorators on a single function lets you layer several behaviors or transformations in a clear and reusable way. In real-world scenarios, you might want to log function calls, validate inputs, cache results, or modify outputs—all without changing the core logic of your function. By chaining decorators, you can build up complex behavior step by step. The order in which you apply decorators matters, as each one wraps the result of the previous, leading to different outcomes depending on how you arrange them.


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_add_two_decorator_adds_2(self):
        import user_code
        importlib.reload(user_code)
        add_two = getattr(user_code, 'add_two_decorator', None)
        _dynamic_test(
            self,
            callable(add_two),
            "add_two_decorator is defined",
            "add_two_decorator is not defined or not callable"
        )
        @add_two
        def f():
            return 5
        result = f()
        _dynamic_test(
            self,
            result == 7,
            "add_two_decorator returns result plus 2",
            f"Expected 7, got {result}"
        )

    def test_square_decorator_squares(self):
        import user_code
        importlib.reload(user_code)
        square = getattr(user_code, 'square_decorator', None)
        _dynamic_test(
            self,
            callable(square),
            "square_decorator is defined",
            "square_decorator is not defined or not callable"
        )
        @square
        def f():
            return 5
        result = f()
        _dynamic_test(
            self,
            result == 25,
            "square_decorator returns squared result",
            f"Expected 25, got {result}"
        )

    def test_combined_decorators_order1(self):
        import user_code
        importlib.reload(user_code)
        output = None
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output_str = f.getvalue().strip()
        _dynamic_test(
            self,
            output_str == "11",
            "Output is 11 when add_two_decorator wraps square_decorator on get_number",
            f"Expected 11, got {output_str}"
        )

    def test_combined_decorators_order2(self):
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Switch order of decorators
        code = code.replace("@add_two_decorator\\n@square_decorator", "@square_decorator\\n@add_two_decorator")
        ns = {}
        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, ns)
        output = f.getvalue().strip()
        _dynamic_test(
            self,
            output == "25",
            "Output is 25 when square_decorator wraps add_two_decorator on get_number",
            f"Expected 25, got {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()
    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 Python decorators, from foundational concepts to advanced applications. This course guides you through the mechanics, use cases, and best practices of decorators, empowering you to write more expressive and reusable Python code.

Explore the foundational concepts of Python decorators, including their syntax, how they work, and why they're useful.

Delve deeper into decorators by exploring arguments, chaining, and built-in decorators.

Explore Python's built-in decorators and practical use cases for custom decorators.

Apply your knowledge of decorators in a series of hands-on coding challenges.

Challenge: Decorator Chaining in Practice

解答