举例讲解Python装饰器-猿码集

1. 什么是Python装饰器

在Python中，装饰器是一种高级别的语法结构，允许在执行函数时动态地修改其行为。装饰器通过包装已有的函数来添加新的功能或修饰其原始函数。Python中几乎所有的框架都使用了装饰器，比如Django中的URL路由和Flask中的HTTP请求方法。装饰器可以极大地提高代码的复用性和灵活性，同时也可以使代码更易于维护和扩展。

2. Python装饰器的语法

装饰器是一个返回函数的高阶函数，它可以接受一个被装饰函数(被修饰)并返回一个新的函数(修饰后)。在Python中，使用@符号可以将函数装饰器应用于函数定义。下面是Python装饰器的基本语法:


@decorator
def function_name():
    # function body

在上面的示例中，decorator是一个装饰器函数，通过@decorator语法将其应用于函数function_name。当我们调用function_name时，实际上是在调用修饰后的函数。

3. Python装饰器的实现

3.1 最简单的Python装饰器

下面是一个最简单的Python装饰器示例，它只简单地将一个函数包装在一个函数中，并在函数调用前后打印日志信息:


def simple_decorator(f):
    def wrapper():
        print('Entering function...')
        f()
        print('Exiting function...')
    return wrapper
@simple_decorator
def say_hello():
    print('Hello, world!')
say_hello()

在上面的示例中，我们首先定义了一个简单的装饰器函数simple_decorator，该函数接受一个函数作为参数并返回一个函数。该函数包含一个内部函数wrapper，在调用被装饰函数前后打印日志信息并在被装饰函数中调用。

接下来，我们使用@simple_decorator装饰函数say_hello。当我们调用say_hello时，实际上是在调用wrapper函数。在示例中，我们将在控制台输出以下内容:

Entering function... Hello, world! Exiting function...

3.2 带参数的Python装饰器

装饰器可以接受参数并根据不同的参数返回不同的装饰器。下面是一个带参数装饰器的示例。


def repeat(num):
    def my_decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(num):
                print('Entering function...')
                func(*args, **kwargs)
                print('Exiting function...')
        return wrapper
    return my_decorator
@repeat(num=3)
def say_hello(name):
    print(f'Hello, {name}!')
say_hello('Python')

在上面的示例中，我们定义了一个repeat装饰器函数，该函数接受一个参数num，并返回另一个装饰器函数my_decorator。my_decorator装饰器函数包含一个内部wrapper函数，该函数接受任意数量的位置和关键字参数(*args和**kwargs)，并在调用函数之前和之后打印日志信息。使用@repeat(num=3)语法将repeat装饰器应用于函数say_hello。当我们调用say_hello('Python')时，实际上是在调用wrapper函数三次。在示例中，我们将在控制台输出以下内容:

Entering function... Hello, Python! Exiting function... Entering function... Hello, Python! Exiting function... Entering function... Hello, Python! Exiting function...

3.3 Python装饰器类的实现

Python装饰器可以被实现为类。装饰器类应该定义__call__方法，该方法接受一个函数作为参数并返回一个新的函数。下面是一个使用类实现的装饰器示例:


class Decorator:
    def __init__(self, func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print('Entering function...')
        self.func(*args, **kwargs)
        print('Exiting function...')
@Decorator
def say_hello():
    print('Hello, world!')
say_hello()

在上面的示例中，我们定义了一个名为Decorator的类，该类定义了__init__方法和__call__方法。__init__方法接受一个函数作为参数。__call__方法包含一个内部函数，在调用函数前后输出日志信息，并调用被装饰函数。最后，我们使用@Decorator语法将装饰器应用于函数say_hello。当我们调用say_hello时，实际上是在调用Decorator类的实例。

4. Python装饰器的应用场景

Python装饰器可以用于许多场景，如日志记录、性能分析、缓存、验证和授权等。下面是几个Python装饰器的常见应用场景:

4.1 日志记录

日志记录是一种在程序中添加日志消息以记录其行为的常用技术。使用装饰器可以轻松地在函数调用前后记录日志消息。下面是一个日志记录器的示例:


def log(f):
    def wrapper(*args, **kwargs):
        print(f'{f.__name__} called')
        return f(*args, **kwargs)
    return wrapper
@log
def say_hello():
    print('Hello, world!')
@log
def calculate_sum(a, b):
    print(f'Sum of {a} and {b} is {a+b}')
say_hello()
calculate_sum(2, 3)

在上面的示例中，我们定义了一个称为log的装饰器函数，该函数接受一个函数并返回一个新函数wrapper，在函数调用前后输出日志消息。当我们使用@log装饰函数say_hello和calculate_sum时，在调用这些函数前后输出日志消息。在示例中，我们将在控制台输出以下内容:

say_hello called Hello, world! calculate_sum called Sum of 2 and 3 is 5

4.2 性能分析

性能分析是一种在程序中测量代码执行时间的技术。使用Python装饰器可以轻松地实现性能分析并输出执行时间。下面是一个性能分析器的示例:


import time
def time_it(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        print(f'{f.__name__} took {end_time - start_time:.6f} seconds to execute')
    return wrapper
@time_it
def calculate_sum():
    sum = 0
    for i in range(10000000):
        sum += i
    print(sum)
calculate_sum()

在上面的示例中，我们定义了一个称为time_it的装饰器函数，该函数接受一个函数并返回一个新函数wrapper，用于测量函数执行时间。当我们使用@time_it装饰函数calculate_sum时，在调用该函数前后输出执行时间。在示例中，我们将在控制台输出以下内容:

49999995000000 calculate_sum took 0.487491 seconds to execute

4.3 缓存

缓存是一种在程序中存储结果以减少重复计算的技术。使用Python装饰器可以轻松地实现缓存并避免重复计算。下面是一个示例，演示了如何使用装饰器实现缓存:


def memoize(f):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = f(*args)
        cache[args] = result
        return result
    return wrapper
@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10))
print(fibonacci(20))

在上面的示例中，我们定义了一个称为memoize的装饰器函数，该函数接受一个函数并返回一个新函数wrapper，用于缓存函数的结果。当我们使用@memoize装饰函数fibonacci时，在调用该函数之前检查结果是否已经存在于缓存中。在示例中，我们将在控制台输出以下内容:

55 6765

4.4 验证和授权

验证和授权是一种在程序中验证用户身份并授权其访问资源的技术。使用Python装饰器可以轻松地实现验证和授权，并确保只有授权用户才能访问资源。下面是一个验证和授权的示例:


def require_authentication(f):
    def wrapper(*args, **kwargs):
        if 'authenticated' in kwargs and kwargs['authenticated']:
            return f(*args, **kwargs)
        else:
            raise Exception('User is not authenticated')
    return wrapper
def require_permission(permission):
    def decorator(f):
        def wrapper(*args, **kwargs):
            if 'permissions' in kwargs and permission in kwargs['permissions']:
                return f(*args, **kwargs)
            else:
                raise Exception(f'User does not have permission {permission}')
        return wrapper
    return decorator
@require_authentication
@require_permission('edit')
def edit_article(article_id, title, content, permissions):
    print(f'Editing article {article_id} with title "{title}" and content "{content}"')
edit_article(article_id=1, title='New Title', content='New Content', permissions=['view', 'edit'])

在上面的示例中，我们定义了两个装饰器函数require_authentication和require_permission，用于验证用户身份和授权用户访问资源。当我们使用@require_authentication装饰@require_permission('edit')装饰函数edit_article时，只有经过身份验证并具有edit权限的用户才能编辑文章。在示例中，我们将在控制台输出以下内容:

Editing article 1 with title "New Title" and content "New Content"

5. Python装饰器的结尾

Python装饰器是一种高级别的语法结构，允许在执行函数时动态地修改其行为。它可以用于许多场景，如日志记录、性能分析、缓存、验证和授权等。使用装饰器可以极大地提高代码的复用性和灵活性，并使代码更易于维护和扩展。Python装饰器是Python开发中的重要技术，深入了解装饰器的工作原理和应用场景对于代码编写非常有帮助。

举例讲解Python装饰器