Decorators in Python are designed to be reusable, meaning you can apply the same decorator to many different functions. This flexibility allows you to add the same behavior—such as logging, timing, or validation—to multiple functions without repeating code. By defining a decorator once and then applying it wherever needed, you keep your codebase clean and consistent. When a decorator is applied to more than one function, each function will receive the additional functionality provided by the decorator, but the core logic of each function remains unchanged. This approach is especially powerful for cross-cutting concerns like debugging or monitoring, where you want to add the same action to various parts of your program.


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_greet_logs_function_name(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet("Alice")
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "greet" in output,
            "Decorator prints 'greet' before greet() runs",
            f"Decorator did not print 'greet'. Output: {output}"
        )

    def test_add_logs_function_name(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add(3, 4)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "add" in output,
            "Decorator prints 'add' before add() runs",
            f"Decorator did not print 'add'. Output: {output}"
        )

    def test_greet_return_value(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.greet("Alice")
        _dynamic_test(
            self,
            result == "Hello, Alice!",
            "greet() returns correct value after decoration",
            f"Expected 'Hello, Alice!', got {result}"
        )

    def test_add_return_value(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.add(3, 4)
        _dynamic_test(
            self,
            result == 7,
            "add() returns correct value after decoration",
            f"Expected 7, 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: Decorate Multiple Functions

解答