You have already learned that a decorator in Python is a function that takes another function as its argument and returns a new function that can add extra behavior before or after the original function runs. Decorators are applied using the `@decorator_name` syntax directly above the function definition. This allows you to modify or enhance functions in a reusable way, without changing their actual code.


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_prints_status(self):
        import user_code

        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet()
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "function started" in output and "function ended" in output,
            'Decorator prints "Function started" and "Function ended" for greet()',
            'Decorator did not print both "Function started" and "Function ended" for greet() call: ' + output
        )

    def test_add_prints_status(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add(1, 2)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "function started" in output and "function ended" in output,
            'Decorator prints "Function started" and "Function ended" for add()',
            'Decorator did not print both "Function started" and "Function ended" for add() call: ' + output
        )

    def test_greet_no_args(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.greet()
            _dynamic_test(
                self,
                True,
                "greet() runs with no arguments",
                "greet() did not run with no arguments"
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "greet() runs with no arguments",
                f"greet() raised an error with no arguments: {e}"
            )

    def test_add_args(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.add(5, 7)
            _dynamic_test(
                self,
                True,
                "add() runs with two arguments",
                "add() did not run with two arguments"
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "add() runs with two arguments",
                f"add() raised an error with two arguments: {e}"
            )

    def test_print_order(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet()
        output = [line.strip().lower() for line in f.getvalue().splitlines() if line.strip()]
        idx_start = None
        idx_end = None
        for idx, line in enumerate(output):
            if line == "function started":
                idx_start = idx
            if line == "function ended":
                idx_end = idx
        _dynamic_test(
            self,
            idx_start is not None and idx_end is not None and idx_start < idx_end,
            '"Function started" is printed before "Function ended"',
            '"Function started" is not printed before "Function ended" in output: ' + str(output)
        )

    def test_add_output_sum(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add(8, 5)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "13" in output,
            'add(8, 5) prints the sum (13)',
            f'add(8, 5) did not print 13, output: {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: Write Your First Decorator

解答