Python 装饰器使用：八个装饰器的巧妙应用-51CTO.COM

装饰器是Python中一种强大的工具，它们可以让你修改或增强函数、方法甚至类的行为，就像是给你的代码披上一层魔法斗篷。今天，我们将通过10个实用的装饰器应用，从基础到进阶，一步步揭开它的面纱。

1. 简单的时间统计装饰器

目的：计算函数执行时间，了解性能。

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timing_decorator
def example_function(n):
    sum(range(n))

example_function(1000000)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

解释：这个装饰器记录了被装饰函数的开始和结束时间，然后计算并打印出耗时。它使用了*args 和 **kwargs 来保持函数的通用性。

2. 参数验证装饰器

用途：确保函数输入参数满足特定条件。

def positive_number_decorator(func):
    def wrapper(number):
        if number < 0:
            raise ValueError("Number must be positive.")
        return func(number)
    return wrapper

@positive_number_decorator
def square(number):
    return number ** 2

try:
    print(square(-5))
except ValueError as e:
    print(e)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

技巧：通过抛出异常来处理不满足条件的情况，保持函数接口的清晰。

3. 缓存装饰器

目的：提高效率，避免重复计算。

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
       return n
    else:
       return (fibonacci(n-1) + fibonacci(n-2))

print(fibonacci(30))  # 只计算一次1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

注意：lru_cache是一个内置的缓存实现，非常适合用于耗时的计算任务。

4. 日志记录装饰器

用途：自动记录函数调用信息。

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned: {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

add(5, 3)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

技巧：这有助于调试和监控程序运行。

5. 类方法装饰器

场景：在类方法上添加额外逻辑。

def class_method_logger(cls_method):
    def wrapper(self, *args, **kwargs):
        print(f"Calling method '{cls_method.__name__}' on {self.__class__.__name__}")
        return cls_method(self, *args, **kwargs)
    return wrapper

class MyClass:
    @class_method_logger
    def say_hello(self, name):
        print(f"Hello, {name}")

MyClass().say_hello("World")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

理解：装饰器同样适用于类方法，增加类行为的灵活性。

6. 异常处理装饰器

目的：统一异常处理逻辑。

def handle_exceptions(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"Error in {func.__name__}: {e}")
    return wrapper

@handle_exceptions
def divide(a, b):
    return a / b

divide(10, 0)  # 安全地处理除零错误1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

7. 计数装饰器

应用场景：跟踪函数调用次数。

class Counter:
    def __init__(self, func):
        self.func = func
        self.calls = 0

    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"Call {self.calls} of {self.func.__name__}")
        return self.func(*args, **kwargs)

@Counter
def greet():
    print("Hello!")

greet()
greet()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

8. 参数默认值检查装饰器

使用：确保函数参数符合预期值。

def check_parameters(expected):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for key, value in kwargs.items():
                if key in expected and value != expected[key]:
                    raise ValueError(f"Invalid value for {key}. Expected {expected[key]}, got {value}.")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@check_parameters({"difficulty": "easy"})
def start_game(difficulty):
    print(f"Starting game with difficulty level {difficulty}.")

start_game(difficulty="medium")  # 触发异常1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

实战案例：Web请求计时与日志记录

假设我们有一个简单的Web请求函数，我们想要记录每次请求的时间并简单记录日志。

import requests
from datetime import datetime

def request_logger(url):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start = datetime.now()
            response = func(url, *args, **kwargs)
            end = datetime.now()
            print(f"Request to {url} completed in {end - start}. Status Code: {response.status_code}")
            return response
        return wrapper
    return decorator

@request_logger("https://api.example.com/data")
def make_request(url):
    return requests.get(url)

make_request()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

分析：这个案例展示了如何结合使用多个功能（计时和日志记录）于一个装饰器中，以监控API调用。在实际开发中，这样的装饰器可以极大地帮助监控和优化服务性能。

通过上述示例，我们不仅掌握了装饰器的基础和进阶应用，还学会了如何根据实际需求设计和实现装饰器，以增强代码的功能性和可维护性。