Python装饰器是一种强大的编程工具，它们可以用于修改或增强函数和方法的行为。装饰器广泛应用于Python开发中，用于解决各种问题，提高代码的可维护性和可重用性。本文将介绍八个高效的Python装饰器，以及它们的用法和示例代码，成为懒人开发的高手。

缓存装饰器

缓存是提高程序性能的重要方式之一。使用缓存装饰器，可以避免重复计算昂贵的函数结果，提高函数执行速度。

以下是一个简单的缓存装饰器示例：

import functools

def memoize(func):
    cache = {}

    @functools.wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]

    return wrapper

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

在上面的例子中，memoize装饰器用于缓存fibonacci函数的结果，避免了重复计算相同参数的斐波那契数。使用装饰器可以让你的代码更干净、更高效。

计时器装饰器

计时器装饰器用于测量函数执行时间，对于性能优化和代码分析非常有用。

以下是一个计时器装饰器的示例：

import time
import functools

def timer(func):
    @functools.wraps(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:.2f} seconds to execute")
        return result

    return wrapper

@timer
def expensive_operation():
    time.sleep(2)

expensive_operation()  # 输出：expensive_operation took 2.00 seconds to execute

在上面的例子中，timer装饰器用于测量expensive_operation函数的执行时间，并输出执行时间。这对于性能分析和优化非常有帮助。

登录验证装饰器

登录验证装饰器用于限制只有已登录用户才能访问某些功能。

以下是一个简单的登录验证装饰器示例：

import functools

def login_required(func):
    @functools.wraps(func)
    def wrapper(user, *args, **kwargs):
        if user.is_authenticated:
            return func(user, *args, **kwargs)
        else:
            return "Access denied. Please login."

    return wrapper

class User:
    def __init__(self, username, is_authenticated=False):
        self.username = username
        self.is_authenticated = is_authenticated

@login_required
def protected_page(user):
    return f"Welcome, {user.username}!"

# 创建一个已登录用户
user = User("John", True)

print(protected_page(user))  # 输出：Welcome, John!

在上述示例中，login_required装饰器用于验证用户是否已登录，如果已登录，则允许访问protected_page函数，否则返回拒绝访问的消息。

日志记录装饰器

日志记录是调试和监视程序行为的重要手段之一。可以使用日志记录装饰器来记录函数的输入、输出和执行时间。

以下是一个简单的日志记录装饰器示例：

import functools
import logging

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_message = f"Calling {func.__name__} with arguments {args} {kwargs}"
        logging.info(start_message)
        result = func(*args, **kwargs)
        end_message = f"{func.__name__} returned {result}"
        logging.info(end_message)
        return result

    return wrapper

@log
def add(x, y):
    return x + y

# 配置日志记录
logging.basicConfig(level=logging.INFO)

result = add(2, 3)

在上述示例中，log装饰器用于记录函数的调用和返回信息。通过配置日志记录，可以更方便地跟踪和调试函数的行为。

输入验证装饰器

输入验证装饰器用于检查函数的输入参数是否合法，以提高程序的健壮性。

以下是一个简单的输入验证装饰器示例：

import functools

def validate_input(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        for arg in args:
            if not isinstance(arg, int):
                raise ValueError("Input arguments must be integers")
        return func(*args, **kwargs)

    return wrapper

@validate_input
def multiply(x, y):
    return x * y

result = multiply(2, 3)  # 正常调用

result = multiply(2, "3")  # 抛出 ValueError

在上述示例中，validate_input装饰器用于验证函数的输入参数是否为整数，如果不是整数，则抛出异常。这有助于提前发现和处理错误输入。

单例模式装饰器

单例模式装饰器用于确保某个类只有一个实例存在。

以下是一个简单的单例模式装饰器示例：

import

 functools

def singleton(cls):
    instances = {}
    
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self, url):
        self.url = url

db1 = DatabaseConnection("http://example.com")
db2 = DatabaseConnection("http://another-example.com")

print(db1 is db2)  # 输出：True

在上述示例中，singleton装饰器用于确保DatabaseConnection类只有一个实例存在。这在需要共享资源或状态的情况下非常有用。

路由装饰器

路由装饰器用于将函数绑定到特定的URL路由上，用于构建简单的Web应用程序或API。

以下是一个简单的路由装饰器示例：

import functools

app_routes = {}

def route(path):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            return func(*args, **kwargs)
        app_routes[path] = wrapper
        return wrapper
    return decorator

@route("/home")
def home():
    return "Welcome to the home page!"

@route("/about")
def about():
    return "This is the about page."

def handle_request(path):
    if path in app_routes:
        return app_routes[path]()
    else:
        return "404 Not Found"

print(handle_request("/home"))  # 输出：Welcome to the home page!
print(handle_request("/about"))  # 输出：This is the about page.
print(handle_request("/contact"))  # 输出：404 Not Found

在上述示例中，route装饰器用于将函数绑定到特定的URL路由上，然后可以通过handle_request函数根据请求的URL来调用对应的函数。

参数化装饰器

参数化装饰器允许你向装饰器传递参数，以根据不同的参数配置不同的装饰器行为。

以下是一个参数化装饰器示例：

import functools

def repeat(n=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(n=3)
def hello():
    print("Hello, world!")

hello()

在上述示例中，repeat装饰器接受一个参数n，用于指定函数被重复调用的次数。通过参数化装饰器，可以轻松地修改装饰器的行为。

总结

Python装饰器是一种强大的工具，可以用于修改函数和方法的行为，增强代码的可读性和可维护性。本文介绍了八个常用的Python装饰器，包括缓存装饰器、计时器装饰器、登录验证装饰器、日志记录装饰器、输入验证装饰器、单例模式装饰器、路由装饰器和参数化装饰器。这些装饰器可以解决各种问题，提高代码质量和效率。