As you have seen in the previous chapter, **logging** is a practical and common use case for decorators in Python. By wrapping a function with a logging decorator, you can automatically record when the function is called, along with its arguments. This approach keeps your code tidy and avoids repetitive logging statements inside every function. **Logging decorators** are especially useful for debugging, monitoring, or auditing function usage in real-world applications.


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_logging(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add(10, 20)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "calling add" in output,
            "Function name 'add' is included in the log",
            f"Expected function name 'add' in log, got: {output}",
        )
        _dynamic_test(
            self,
            "args=(10, 20)" in output,
            "Positional arguments are logged correctly",
            f"Expected 'args=(10, 20)' in log, got: {output}",
        )
        _dynamic_test(
            self,
            "kwargs={}" in output,
            "Empty keyword arguments are logged correctly",
            f"Expected 'kwargs={{}}' in log, got: {output}",
        )

    def test_greet_function_logging_positional(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet("Charlie")
        output = f.getvalue()
        # Check for exact match with tuple representation for single argument
        _dynamic_test(
            self,
            "Calling greet with args=('Charlie',), kwargs={}" in output,
            "Single positional argument is logged correctly",
            f"Expected log: Calling greet with args=('Charlie',), kwargs={{}}. Got: {output}",
        )

    def test_greet_function_logging_keyword(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet("Bob", greeting="Hi")
        output = f.getvalue()
        # Accept both single and double quotes in dict for kwargs
        cond = (
            "Calling greet with args=('Bob',), kwargs={'greeting': 'Hi'}" in output or
            'Calling greet with args=(\\'Bob\\',), kwargs={"greeting": "Hi"}' in output
        )
        _dynamic_test(
            self,
            cond,
            "Keyword argument is logged correctly for greet",
            f"Expected log with positional and keyword args. Got: {output}",
        )

    def test_original_functionality(self):
        import user_code
        importlib.reload(user_code)
        result_add = user_code.add(7, 5)
        result_greet = user_code.greet("Dana")
        _dynamic_test(
            self,
            result_add == 12,
            "add function returns correct result",
            f"Expected add(7, 5) == 12, got: {result_add}",
        )
        _dynamic_test(
            self,
            result_greet == "Hello, Dana!",
            "greet function returns correct result",
            f"Expected greet('Dana') == 'Hello, Dana!', got: {result_greet}",
        )

    def test_functionality_with_kwargs(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.greet("Eve", greeting="Welcome")
        _dynamic_test(
            self,
            result == "Welcome, Eve!",
            "greet function returns correct result with keyword argument",
            f"Expected greet('Eve', greeting='Welcome') == 'Welcome, Eve!', 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: Logging Decorator

解答