装饰器：Decorators
Python装饰器接收一个函数对象，添加一些功能，并返回该函数对象。在本文中，你将了解如何创建装饰器(decorator)以及为什么要使用它。
Python 有一个有趣的特性叫做装饰器，可以在不改动现有代码的情况下添加新功能。这也称为元编程（metaprogramming），因为程序的一部分试图在编译时修改程序的另一部分。
为了理解装饰器，我们必须首先了解 Python 中的一些基本知识。
我们必须接受这样一个事实，即 Python 中的所有内容(即使是类) 都是对象，一切皆对象。我们定义的名称只是绑定到这些对象的标识符。函数也不例外，它们也是对象(带有属性)。
- 可以将各种不同的名称绑定到同一个函数对象
举个栗子：
# 定义一个普通函数
def first(msg):
print(msg)
first("干饭人") # 调用first函数
second = first # 将first函数赋值给second变量
second("干饭人") # 调用second函数
输出：
干饭人
干饭人
当您运行代码时，第一个和第二个函数都给出相同的输出。这里，第一个和第二个名称指的是同一个函数对象。
- 函数可以作为参数传递给另一个函数
现在事情开始变得有点意思了。
如果你在 Python 中使用过 map()、 filter() 和 reduce() 等函数，那么你肯定已经是老司机了。将其他函数作为参数的函数也称为高阶函数（higher order functions）。
举个栗子：
def add(x):
return x + 1
def lose(x):
return x - 1
def operate(func, x):
result = func(x)
return result
我们按照以下方式调用该函数。
operate(add,3) # 输出：4
operate(lose,3) # 输出：2
- 一个函数可以返回另一个函数。
既然函数是对象，那么你都可以作为其他函数的入参了，把你作为高阶函数的返回值应该不过分吧。
举个栗子：
def is_called():
def is_returned():
print("干饭人")
return is_returned
new = is_called()
new()
这里，is_returned()是一个嵌套函数，每次调用 is _called()时定义并返回该函数。
输出：
干饭人
- 闭包
最后，我们必须了解 Python 中的闭包（Closure），这里不赘述了，敬请移步至小主相关博文。
装饰器
函数和方法被称为可调用对象（callable），因为它们可以被调用。
实际上，任何实现魔法方法 __call__()的对象都称为可调用的（callable）。因此，我们可以得出一个结论：装饰器是一个可调用对象，它用来返回一个可调用对象。
A decorator is a callable that returns a callable.
通常，装饰器会接受一个函数，添加一些功能，最后返回该函数。
举个栗子:
# 声明第一个函数make_pretty
def make_pretty(func):
def inner():
print("我是make_pretty，我来搞点事情")
func()
return inner
# 声明第二个函数ordinary
def ordinary():
print("我是ordinary，我的内心毫无波澜")
如果我们执行代码：
ordinary()
输出：
我是ordinary，我的内心毫无波澜
如果我们执行代码：
pretty = make_pretty(ordinary)
pretty()
则会输出：
我是make_pretty，我来搞点事情
我是ordinary，我的内心毫无波澜
在上面的例子中，pretty = make_pretty(ordinary) 表明 make_pretty()是一个装饰器，ordinary函数被装饰，返回的函数指定名称为pretty。
我们可以看到 decorator 函数向原始函数添加了一些新功能。这类似于包装礼物。Decorator 充当包装器。被装饰的对象的性质(里面的实际礼物)不会改变。但是现在，它看起来很漂亮(因为它被装饰过)。
通常，我们将函数装饰为：ordinary = make_pretty(ordinary)。
这是一个常见的构造，出于这个原因，Python 使用了一种语法来简化它。
我们可以将 @ 符号与装饰器函数的名称一起使用，并将其置于要装饰的函数的定义之上。这只是实现装饰器的一个语法糖。
举个栗子：
@make_pretty
def ordinary():
print("I am ordinary")
效果相当于：
def ordinary():
print("I am ordinary")
ordinary = make_pretty(ordinary)
装饰器参数
前面演示的装饰器很简单，它只处理没有任何参数的函数。
如果我们有这样的函数:
def divide(a, b):
return a/b
divide(2,5) # 输出：0.4
divide(2,0) # 报错 “ZeroDivisionError: division by zero”
这个函数有两个参数 a 和 b。我们知道如果我们把分母 b 传入0，将会导致ZeroDivisionError错误。
现在让我们创建一个装饰器来检查这个会导致错误的情况。
优化后：
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。
如果执行：
print(divide(2,5))
输出：
将要计算 2 除以 5
0.4
如果执行：
print(divide(2,0))
输出：
将要计算 2 除以 0
分母不能为0！
None
通过这种方式，我们可以装饰带有参数的函数。
细心的朋友会注意到，装饰器 smart_divide 中嵌套的 inner() 函数的参数与它所装饰的函数的参数是相同的。
考虑到这一点，现在我们可以使通用装饰符与任意数量的参数一起工作。
在 Python 中，可以写成这样：function(*args, **kwargs)。其中，args 表示位置参数组成的元组，而 kwargs 表示关键字参数组成的字典。其中*号和**号表示参数个数不限。
举个栗子：
def works_for_all(func):
def inner(*args, **kwargs):
print("I can decorate any function")
return func(*args, **kwargs)
return inner
装饰器嵌套
在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("我是宇宙中心")
上面的双迭代器的效果相当于：
def printer(msg):
print(msg)
printer = star(percent(printer))
输出：
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
我是宇宙中心
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************
需要注意的是，我们装饰链的顺序很重要。
如果我们颠倒了顺序：
@percent
@star
def printer(msg):
print(msg)
输出结果将是：
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************
我是宇宙中心
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
好的，以上就是关于Python装饰器的全部内容了。喜欢本文的小伙伴记得三连哦~
---END
Talk is cheap, just show me the code!