In the previous chapters, you learned about the **decorator factory pattern**—a technique that allows you to create decorators which themselves accept arguments. This pattern involves defining an outer function that takes the decorator arguments and returns the actual decorator, which then wraps the target function. This approach enables you to build highly flexible and reusable decorators that can be customized for different use cases.


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_function(self):
        import user_code
        importlib.reload(user_code)
        add = getattr(user_code, 'add', None)
        _dynamic_test(
            self,
            callable(add),
            "'add' function is defined and callable",
            "'add' function is not defined or not callable",
        )
        result = add(2, 4)
        _dynamic_test(
            self,
            result == 18,
            "add(2, 4) returns 18 (6 * 3)",
            f"add(2, 4) should return 18, got {result}",
        )

    def test_subtract_function(self):
        import user_code
        importlib.reload(user_code)
        subtract = getattr(user_code, 'subtract', None)
        _dynamic_test(
            self,
            callable(subtract),
            "'subtract' function is defined and callable",
            "'subtract' function is not defined or not callable",
        )
        result = subtract(10, 6)
        _dynamic_test(
            self,
            result == 20,
            "subtract(10, 6) returns 20 (4 * 5)",
            f"subtract(10, 6) should return 20, got {result}",
        )

    def test_generic_numeric_function(self):
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
        code += '\\n' + """
@multiply_result(10)
def square(x):
    return x * x
result = square(3)
"""
        ns = {}
        exec(code, ns)
        result = ns.get('result', None)
        _dynamic_test(
            self,
            result == 90,
            "Decorator works for any numeric return value (square(3) == 9, multiplied by 10 == 90)",
            f"Expected 90 from decorated square(3), 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 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: Parameterized Decorator

解答