Python中的装饰器|极客教程

Python中的装饰器

装饰器（Decorator）是Python中一个强大且常用的功能，它可以在不改变原函数代码的情况下，为函数添加额外的功能。装饰器是Python的一种语法糖，可以简化代码的编写，提高代码的可读性和可维护性。本文将详细解释Python中装饰器的概念、用法和实际应用。

什么是装饰器

装饰器本质上是一个闭包函数，它接收一个函数作为参数，并返回一个新的函数。这个新的函数可以在不改变原函数的情况下，为原函数添加一些额外功能。装饰器的语法比较特殊，使用@符号放在函数定义上方来使用。

下面是一个简单的装饰器示例：

def decorator(func):
    def wrapper():
        print("Before calling original function")
        func()
        print("After calling original function")
    return wrapper

@decorator
def hello():
    print("Hello, world!")

hello()

运行结果：

Before calling original function
Hello, world!
After calling original function

在上面的示例中，decorator是一个装饰器函数，它接收一个函数func作为参数，并定义了一个内部函数wrapper，在调用原函数前后分别输出一句提示信息。通过使用@decorator语法，将hello函数传入decorator函数中进行装饰，最终调用hello函数时实际上是调用了wrapper函数，从而实现了为原函数添加额外功能的效果。

装饰器的应用场景

装饰器在实际开发中有很多应用场景，常用的有日志记录、性能测试、权限验证、参数校验等。下面分别介绍这些常见应用场景的装饰器实现。

日志记录

日志记录是开发中常见的需求，通过在函数执行前后输出日志消息可以帮助程序员调试和排查问题。下面是一个简单的日志记录装饰器示例：

import datetime

def log(func):
    def wrapper(*args, **kwargs):
        print("{} - Calling function {}".format(datetime.datetime.now(), func.__name__))
        result = func(*args, **kwargs)
        print("{} - Function {} finished".format(datetime.datetime.now(), func.__name__))
        return result
    return wrapper

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

result = add(2, 3)
print("Result:", result)

运行结果：

2022-01-01 12:00:00 - Calling function add
2022-01-01 12:00:00 - Function add finished
Result: 5

在上面的示例中，log装饰器函数定义了一个内部函数wrapper，在调用原函数add前后分别输出日志消息。通过使用@log语法，将add函数传入log函数中进行装饰，最终实现了日志记录的功能。

性能测试

性能测试是优化程序性能的重要手段，通过装饰器可以方便地为函数添加计时功能，用于记录函数执行的时间，帮助分析程序的性能瓶颈。下面是一个简单的性能测试装饰器示例：

import time

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

@performance_test
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

result = fib(35)
print("Result:", result)

运行结果：

Function fib took 4.503047 seconds
Result: 9227465

在上面的示例中，performance_test装饰器函数定义了一个内部函数wrapper，在调用原函数fib前后分别记录了函数执行的时间。通过使用@performance_test语法，将fib函数传入performance_test函数中进行装饰，最终实现了性能测试的功能。

权限验证

权限验证是保护资源安全的重要手段，通过装饰器可以方便地为函数添加权限验证功能，用于限制用户对资源的访问。下面是一个简单的权限验证装饰器示例：

is_authenticated = True

def auth_required(func):
    def wrapper(*args, **kwargs):
        if is_authenticated:
            return func(*args, **kwargs)
        else:
            print("Unauthorized access!")
    return wrapper

@auth_required
def secure_function():
    print("This is a secure function")

secure_function()

运行结果：

This is a secure function

在上面的示例中，auth_required装饰器函数定义了一个内部函数wrapper，在调用原函数secure_function前进行权限验证，只有在用户已经认证的情况下才能调用原函数。通过使用@auth_required语法，将secure_function函数传入auth_required函数中进行装饰，最终实现了权限验证的功能。

参数校验

参数校验是保证函数输入的有效性的重要手段，通过装饰器可以方便地为函数添加参数校验功能，用于检查函数输入的合法性。下面是一个简单的参数校验装饰器示例：

def validate(func):
    def wrapper(*args, **kwargs):
        for arg in args:
            if not isinstance(arg, int):
                print("Invalid argument type: {}".format(type(arg)))
                return
        return func(*args, **kwargs)
    return wrapper

@validate
def sum_numbers(*args):
    return sum(args)

result = sum_numbers(1, 2, 3, 'a')
print("Result:", result)

运行结果：

Invalid argument type: <class 'str'>
Result: None

在上面的示例中，validate装饰器函数定义了一个内部函数wrapper，在调用原函数sum_numbers前进行参数校验，检查传入的参数是否为整数类型。通过使用@validate语法，将sum_numbers函数传入validate函数中进行装饰，最终实现了参数校验的功能。

多个装饰器的嵌套

在Python中可以为一个函数同时应用多个装饰器，这时装饰器的顺序非常重要，它们的执行顺序是从内向外的。下面是一个多个装饰器嵌套的示例：

def log(func):
    def wrapper(*args, **kwargs):
        print("Log: Calling function {}".format(func.__name__))
        return func(*args, **kwargs)
    return wrapper

def timeit(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print("Time: Function {} took {:.6f} seconds".format(func.__name__, end_time - start_time))
        return result
    return wrapper

@timeit
@log
def multiply(x, y):
    return x * y

result = multiply(5, 7)
print("Result:", result)

运行结果：

Log: Calling function multiply
Time: Function multiply took 0.000001 seconds
Result: 35

在上面的示例中，log和timeit是两个装饰器函数，分别用来输出日志和计时。通过使用@timeit和@log语法，将multiply函数依次传入timeit和log函数中进行装饰，最终实现了先输出日志再计时的功能。

带参数的装饰器

有时候我们需要为装饰器传入参数，可以通过在装饰器外层再包裹一个函数来实现带参数的装饰器。下面是一个带参数的装饰器示例：

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

@repeat(3)
def greet(name):
    print("Hello, {}!".format(name))

greet("Alice")

运行结果：

Hello, Alice!
Hello, Alice!
Hello, Alice!

在上面的示例中，repeat是一个带参数的装饰器外层函数，它接收一个重复次数n，并返回一个装饰器内层函数decorator。通过使用@repeat(3)语法，将greet函数传入repeat函数中进行装饰，最终实现了对greet函数重复执行3次的功能。

总结

装饰器是Python中非常重要且强大的功能，它可以为函数添加额外的功能而不需要修改原函数的代码。通过本文的介绍，你应该已经了解了装饰器的概念、用法和常见应用场景，并学会了如何编写简单和复杂的装饰器。在实际开发中，善于使用装饰器可以让代码更加优雅和可维护，提高开发效率和代码质量。

Python中的装饰器