【Python 元编程】装饰器入门指南

Python装饰器入门指南🚀

在编程世界中，效率和优雅的代码往往是我们所追求的目标。Python 作为一种强大且灵活的编程语言，提供了一个称为“装饰器”的功能，让我们能够以一种简洁和优雅的方式扩展和管理我们的代码。

本文旨在为初学者提供一个关于 Python 装饰器的简明指南，帮助大家理解它们的基本概念、作用以及在实际编程中的应用。让我们开始这趟探索之旅，一步步揭开装饰器神秘的面纱吧！🌟

知识点📖

什么是装饰器? 🤔

官网：什么是装饰器？

以下内容引用于官网：

返回值为另一个函数的函数，通常使用 @wrapper 语法形式来进行函数变换。 装饰器的常见例子包括 classmethod() 和 staticmethod()。

装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:

def f(arg):
    ...
f = staticmethod(f)

@staticmethod
def f(arg):
    ...

在 Python 中，装饰器是一种强大的编程结构，它们允许在不修改原有函数代码的情况下增强或改变函数的行为。装饰器本质上是一个函数，它接收一个函数作为参数并返回一个新的函数。

装饰器的作用 🚀

装饰器的主要作用是为现有的函数或方法添加额外的功能。它们提供了一种优雅的方式来扩展函数的功能，这在维护和调试代码时非常有用，特别是在遵循开放/封闭原则的情况下。

• 修改函数或方法的行为：通过装饰器在不更改原始代码的情况下修改函数或方法的行为。例如，添加日志记录、性能计时器或输入验证。
• 提高代码的可读性：装饰器允许将与函数相关的代码块独立封装，使代码更加清晰和易于理解。
• 促进代码的重用：创建通用的装饰器，然后在多个函数或方法中重复使用它们，从而避免代码重复。

装饰器的应用场景 🌍

装饰器在许多应用场景中都非常有用，包括但不限于：

• 日志记录：自动记录函数的调用细节。
• 性能测试：检测函数运行时间。
• 权限验证：检查调用者是否有权执行某个函数。
• 缓存：为耗时的操作结果添加缓存。

为什么使用装饰器?💡

这里使用一个简单的案例来展开说明。

我有一份网络请求的代码如下所示，

import requests


def network_request():
    return requests.get(url='https://www.baidu.com').text[:10]


if __name__ == '__main__':
    network_request()

现在需要为它添加一个执行耗时的功能！

• 啪的一下！很快啊，就添加了这个功能。这也太简单了！

import time


if __name__ == '__main__':
    st = time.time()
    res = network_request()
    print(res)
    et = time.time()
    print(f'共耗时{et - st} 秒')

紧接着，又需要请求其它网络请求，并且要分别计算它们的执行耗时。

啪的一下，还是很快，我改好了代码。简单的来又有点麻烦！

def network_request2():
    return requests.get(url='https://www.bilibili.com').text[:10]


if __name__ == '__main__':
    st = time.time()
    network_request()
    et = time.time()
    print(f'{network_request.__name__} 共耗时{et - st} 秒')
    #
    st = time.time()
    network_request2()
    et = time.time()
    print(f'{network_request2.__name__} 共耗时{et - st} 秒')

再紧接着，又有其它网络请求，并且要分别计算它们的执行耗时。

这时候我开始头疼了！于是我开始吃头疼药

于是我用上了 一个名叫 装饰器 功能！头竟然神奇的不疼了！！！

• 在这里，我们定义了一个名为 timer 的装饰器，用于记录函数执行的时间。它是一个函数，接受一个函数作为传参，通过使用装饰器，我们可以轻松地为多个网络请求函数分别添加执行耗时的功能，而不必重复编写计时逻辑。这使得代码更加整洁和易于维护，同时提高了代码的可复用性。

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time} 秒")
        return result

    return wrapper

这时再来看添加了执行耗时的代码，

• 啪的一下，这次就很方便了！

@timer
def network_request():
    return requests.get(url='https://www.baidu.com').text[:10]
# 等同于 timer(network_request)

@timer
def network_request2():
    return requests.get(url='https://www.bilibili.com').text[:10]
# 等同于 timer(network_request2)


if __name__ == '__main__':
    print(network_request())
    print(network_request2())

看到这，你应该明白为什么需要使用以及什么时候需要装饰器了吧！

这个案例介绍的不够全面，但试想一下，你在接手别人的项目时候，想要添加一个日志记录或执行耗时的功能来扩展项目功能，你更想直接上手改代码，还是使用装饰器来完成呢！！！

代码实现

基础装饰器 🛠?

用回上述的代码，

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time} 秒")
        return result

    return wrapper

代码释义：

这个函数 timer 是一个装饰器函数，它的作用是为被装饰的函数添加计时功能。具体来说：

1. 它接受一个函数 func 作为参数，这个函数即将被装饰的目标函数。

2. 在 timer 函数内部，定义了一个嵌套函数 wrapper，这个函数将替代原始的目标函数。

3. 在 wrapper 函数内部，记录了目标函数执行前的时间戳（start_time），然后调用原始的目标函数 func(*args, **kwargs) 来执行它，并记录执行后的时间戳（end_time）。

4. 计算出函数执行的时间差，并使用 print 函数输出执行时间。

5. 最后，wrapper 函数返回了原始函数 func 的执行结果，并成为了新的目标函数。

当你使用 @timer 装饰器来修饰一个函数时，它会自动将该函数替换为 wrapper 函数，从而在函数执行时会自动记录并输出执行时间，而无需修改原始函数的代码。这个装饰器可以用来统计函数的执行效率或者做性能分析。

---

接受传参的装饰器 📌

装饰器也可以接受外部参数，这需要在装饰器中添加另一个层级的函数：

import time
import requests


def repeat_decorator(repeat_time):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(repeat_time):
                try:
                    return func(*args, **kwargs)
                except requests.RequestException as e:
                    print(f'第 {i} 次, 错误', e.args)

        return wrapper

    return decorator


@repeat_decorator(repeat_time=3)
def network_request():
    return requests.get(url='https://www.bilibili.com').text[:10]


if __name__ == '__main__':
    network_request()

代码释义：

这函数定义了一个装饰器 repeat_decorator，它的作用是用于处理函数执行时可能出现的异常并进行重试。具体介绍如下：

1. repeat_decorator 是一个装饰器函数，它接受一个参数 repeat_time，表示重试的次数。

2. 在 repeat_decorator 内部，定义了一个嵌套的函数 decorator，这个函数接受一个函数 func 作为参数，这个 func 即将被装饰的目标函数。

3. 在 decorator 函数内部，定义了另一个嵌套函数 wrapper，这个函数将替代原始的目标函数。

4. 在 wrapper 函数内部，使用 for 循环进行多次尝试，尝试调用原始的目标函数 func(*args, **kwargs)。

5. 如果调用 func 过程中发生了 requests.RequestException 异常，它会捕获异常，并输出错误信息，同时继续进行下一次重试。

6. 当函数成功执行或者达到了指定的重试次数后，返回最后一次执行的结果。

这个装饰器的作用是增强目标函数的健壮性，当目标函数可能因网络请求等原因而抛出异常时，它会尝试多次执行该函数，以增加函数的成功执行的机会。这对于处理不稳定的网络请求或者需要重试的操作非常有用。

输出：

• 假设请求错误，则会打印以下结果，打印内容有删减！

第 0 次, 错误 (MaxRetryError("Failed to establish a new connection: [WinError 10061] 由于目标计算机积极拒绝，无法连接。')))"),)
第 1 次, 错误 (MaxRetryError("Failed to establish a new connection: [WinError 10061] 由于目标计算机积极拒绝，无法连接。')))"),)
第 2 次, 错误 (MaxRetryError("Failed to establish a new connection: [WinError 10061] 由于目标计算机积极拒绝，无法连接。')))"),)

为装饰器动态添加属性 ?

装饰器还可以用来动态地给函数添加属性。以下是一个使用partial函数和setattr的示例：

• 这个装饰器允许我们动态地将test2函数作为test的一个属性添加上去。

from functools import partial

def attach_wrapper(obj, func=None):
    if not func:
        return partial(attach_wrapper, obj)
    setattr(obj, func.__name__, func)
    return func

def test():
    print('This is test.')

@attach_wrapper(test)
def test2():
    print('This is test 2.')

if __name__ == '__main__':
    test()
    test.test2()

代码释义：

这添加属性的装饰器允许你将一个函数动态地添加为另一个函数的属性。具体作用如下：

1. 定义了一个装饰器函数 attach_wrapper，它接受两个参数：obj 和 func。obj 表示要附加属性的目标对象（通常是一个函数），而 func 是要添加为属性的函数。

2. 如果 func 为空，则返回一个 partial 函数，该 partial 函数接受一个参数 obj，用于表示要附加属性的目标对象。这是一种延迟调用的方式，允许你稍后再次调用装饰器并传递 func 参数。

3. 如果 func 不为空，它将使用 setattr 函数将 func 添加为 obj 的属性，属性名称为 func.__name__，即 func 函数的名称。

4. 装饰器函数的返回值是 func，因此它不会影响原始函数的行为。

通过这种装饰器，你可以将一个函数（例如 test2）动态地添加为另一个函数（例如 test）的属性。这可以在一些情况下提供便利，使你能够轻松地访问和管理相关的函数，特别是在需要扩展函数的功能或者将一些相关的操作组织在一起时。

但事实上，上面的代码等价于下面：

def test():
    print('This is test.')

    
def test2():
    print('This is test 2.')


setattr(test, test2.__name__, test2)

总结

通过本文的学习，我们不仅掌握了 Python 装饰器的基础知识，还了解了它们在实际编程中的多种应用场景。装饰器不仅提高了代码的可重用性和可维护性，还增强了代码的可读性和优雅度。它们是 Python 编程中不可或缺的一部分，无论是简化代码、增加功能还是进行性能分析，都能发挥重要作用。🚀🚀🚀