Python中的装饰器

装饰器：Decorators

Python装饰器接收一个函数对象，添加一些功能，并返回该函数对象。在本文中，你将了解如何创建装饰器(decorator)以及为什么要使用它。

Python 有一个有趣的特性叫做装饰器，可以在不改动现有代码的情况下添加新功能。这也称为元编程（metaprogramming），因为程序的一部分试图在编译时修改程序的另一部分。

先决条件

为了理解装饰器，我们必须首先了解 Python 中的一些基本知识。

我们必须接受这样一个事实，即 Python 中的所有内容(即使是类) 都是对象，一切皆对象。我们定义的名称只是绑定到这些对象的标识符。函数也不例外，它们也是对象(带有属性)。

• 可以将各种不同的名称绑定到同一个函数对象

举个栗子：

复制代码
1
2
3
4
5
6
7
python
# 定义一个普通函数
def first(msg):
    print(msg)

first("干饭人")   # 调用first函数
second = first   # 将first函数赋值给second变量
second("干饭人")  # 调用second函数

输出：

复制代码
1
2
text
干饭人
干饭人

当您运行代码时，第一个和第二个函数都给出相同的输出。这里，第一个和第二个名称指的是同一个函数对象。

• 函数可以作为参数传递给另一个函数

现在事情开始变得有点意思了。

如果你在 Python 中使用过 map()、 filter() 和 reduce() 等函数，那么你肯定已经是老司机了。将其他函数作为参数的函数也称为高阶函数（higher order functions）。

举个栗子：

复制代码
1
2
3
4
5
6
7
8
9
10
11
python
def add(x):
    return x + 1


def lose(x):
    return x - 1


def operate(func, x):
    result = func(x)
    return result

我们按照以下方式调用该函数。

复制代码
1
2
python
operate(add,3)  # 输出：4
operate(lose,3)  # 输出：2

• 一个函数可以返回另一个函数。

既然函数是对象，那么你都可以作为其他函数的入参了，把你作为高阶函数的返回值应该不过分吧。

举个栗子：

复制代码
1
2
3
4
5
6
7
8
python
def is_called():
    def is_returned():
        print("干饭人")
    return is_returned


new = is_called()
new()

这里，is_returned()是一个嵌套函数，每次调用 is _called()时定义并返回该函数。

输出：

复制代码
1
text
干饭人

• 闭包

最后，我们必须了解 Python 中的闭包（Closure），这里不赘述了，敬请移步至小主相关博文。

装饰器

函数和方法被称为可调用对象（callable），因为它们可以被调用。

实际上，任何实现魔法方法 __call__()的对象都称为可调用的（callable）。因此，我们可以得出一个结论：装饰器是一个可调用对象，它用来返回一个可调用对象。

A decorator is a callable that returns a callable.

通常，装饰器会接受一个函数，添加一些功能，最后返回该函数。

举个栗子:

复制代码
1
2
3
4
5
6
7
8
9
10
python
# 声明第一个函数make_pretty
def make_pretty(func):
    def inner():
        print("我是make_pretty，我来搞点事情")
        func()
    return inner

# 声明第二个函数ordinary
def ordinary():
    print("我是ordinary，我的内心毫无波澜")

如果我们执行代码：

复制代码
1
python
ordinary()

输出：

复制代码
1
text
我是ordinary，我的内心毫无波澜

如果我们执行代码：

复制代码
1
2
python
pretty = make_pretty(ordinary)
pretty()

则会输出：

复制代码
1
2
text
我是make_pretty，我来搞点事情
我是ordinary，我的内心毫无波澜

在上面的例子中，pretty = make_pretty(ordinary) 表明 make_pretty()是一个装饰器，ordinary函数被装饰，返回的函数指定名称为pretty。

我们可以看到 decorator 函数向原始函数添加了一些新功能。这类似于包装礼物。Decorator 充当包装器。被装饰的对象的性质(里面的实际礼物)不会改变。但是现在，它看起来很漂亮(因为它被装饰过)。

通常，我们将函数装饰为：ordinary = make_pretty(ordinary)。

这是一个常见的构造，出于这个原因，Python 使用了一种语法来简化它。

我们可以将 @ 符号与装饰器函数的名称一起使用，并将其置于要装饰的函数的定义之上。这只是实现装饰器的一个语法糖。

举个栗子：

复制代码
1
2
3
python
@make_pretty
def ordinary():
    print("I am ordinary")

效果相当于：

复制代码
1
2
3
python
def ordinary():
    print("I am ordinary")
ordinary = make_pretty(ordinary)

装饰器参数

前面演示的装饰器很简单，它只处理没有任何参数的函数。

如果我们有这样的函数:

复制代码
1
2
3
4
5
python
def divide(a, b):
    return a/b

divide(2,5)  # 输出：0.4
divide(2,0)  # 报错 “ZeroDivisionError: division by zero”

这个函数有两个参数 a 和 b。我们知道如果我们把分母 b 传入0，将会导致ZeroDivisionError错误。

现在让我们创建一个装饰器来检查这个会导致错误的情况。

优化后：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
python
def smart_divide(func):
    def inner(a, b):
        print(f"将要计算 {a} 除以 {b}")
        if b == 0:
            print("分母不能为0！")
            return

        return func(a, b)
    return inner


@smart_divide
def divide(a, b):
    print(a/b)

解释：如果出现错误条件，这个新实现将返回 None。

如果执行：

复制代码
1
python
print(divide(2,5))

输出：

复制代码
1
2
text
将要计算 2 除以 5
0.4

如果执行：

复制代码
1
python
print(divide(2,0))

输出：

复制代码
1
2
3
text
将要计算 2 除以 0
分母不能为0！
None

通过这种方式，我们可以装饰带有参数的函数。

细心的朋友会注意到，装饰器 smart_divide 中嵌套的 inner() 函数的参数与它所装饰的函数的参数是相同的。

考虑到这一点，现在我们可以使通用装饰符与任意数量的参数一起工作。

在 Python 中，可以写成这样：function(*args, **kwargs)。其中，args 表示位置参数组成的元组，而 kwargs 表示关键字参数组成的字典。其中*号和**号表示参数个数不限。

举个栗子：

复制代码
1
2
3
4
5
python
def works_for_all(func):
    def inner(*args, **kwargs):
        print("I can decorate any function")
        return func(*args, **kwargs)
    return inner

装饰器嵌套

在python中，装饰器可以嵌套使用，有点像套娃。也就是说，一个函数可以使用不同(或相同)的装饰器进行多次装饰。我们只需简单地将装饰器置于期望的函数之上即可实现。

举个栗子：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
python
def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner


def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner


@star
@percent
def show(msg):
    print(msg)


show("我是宇宙中心")

上面的双迭代器的效果相当于：

复制代码
1
2
3
python
def printer(msg):
    print(msg)
printer = star(percent(printer))

输出：

复制代码
1
2
3
4
5
text
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
我是宇宙中心
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************

需要注意的是，我们装饰链的顺序很重要。

如果我们颠倒了顺序：

复制代码
1
2
3
4
python
@percent
@star
def printer(msg):
    print(msg)

输出结果将是：

复制代码
1
2
3
4
5
text
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************
我是宇宙中心
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

好的，以上就是关于Python装饰器的全部内容了。喜欢本文的小伙伴记得三连哦~

---END