【低门槛 手把手】python 装饰器(Decorators)原理说明
本文目的是由浅入深地介绍python装饰器原理
装饰器(Decorators)是 Python 的一个重要部分
其功能是， 在不修改原函数(类)定义代码的情况下，增加新的功能
为了理解和实现装饰器，我们先引入2个核心操作：
1 必要的2个核心操作
1.1 核心操作1， 函数内部可以定义函数
def hi(name='world'):
print(f"hello, {
name}")
def howdoyoudo(name2=name):
print(f"how do you do? {
name2}")
howdoyoudo()
howdoyoudo('world')
hi("ytt") # 但是新函数还是存在的。
hi("ycy") # 但是新函数还是存在的。
try:
howdoyoudo()
except:
print("function not found")
在这个例子中，函数hi的形参name，默认为’world’
在函数内部，又定义了另一个函数 howdoyoudo，定义这个函数时，将形参name作为新函数的形参name2的默认值。
因此，在函数内部调用howdoyoudo()时，将以调用hi时的实参为默认值，但也可以给howdoyoudo输入其他参数。
上面的例子运行后输出结果为：
hello, ytt how do you do? ytt how do you do? world hello, ycy how do you do? ycy how do you do? worldfunction not found
这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念，但其实没必要给它取一个多专业的名字。我们知道闭包是 函数内的函数 就可以了
1.2 核心操作2 函数可以作为对象被输入输出
1.2.1 核心操作2的前置条件，函数是对象
当我们进行 def 的时候，我们在做什么？
def hi():
print("hi")
return "world"
这时，hi函数，打印一个字符串，同时返回一个字符串。
但hi函数本身也是一个对象，一个可以执行的对象。执行的方式是hi()。
这里hi和hi()有本质区别，
hi 代表了这个函数对象本身
hi() 则是运行了函数，得到函数的返回值。
def hi(name='world'):
print(f"hello, {
name}")
return name
msg = hi() # 运行函数，返回字符串，因此msg是个字符串
print(msg)
hello = hi # 将函数本身赋值给hello，此时hello是另一个函数，即使删除原函数hi，新函数hello也可以正常调用
del hi # 删除原函数hi
try:
hi()
except:
print("func hi not found")
hello("ycy") # 但是新函数还是存在的。
作为对比，可以想象以下代码
a = 'example'
b = a
del a
此时也是b存在，可以正常使用。
1.2.2函数作为输入
我们定义2个函数，分别实现自加1， 自乘2，
再定义一个函数double_exec，内容是将某个函数调用2次
在调用double_exec时，可以将函数作为输入传进来
def func1(n):
return n+1
def func2(n):
return n*2
def double_exec(f,x):
return f(f(x))
rst = double_exec(func1, 5)
print(rst)
rst = double_exec(func2, 3)
print(rst)
输出结果就是
7
27
1.2.3 函数作为输出
同样，也可以将函数作为输出
def select_func(i):
def func1(n):
return n+1
def func2(n):
return n*2
func_list = [func1, func2]
return func_list[i]
func = select_func(0) # 第1个函数
print(func(5))
func = select_func(1) # 第2个函数
print(func(5))
输出结果为
6
10
2 尝试构造装饰器
有了以上两个核心操作，我们可以尝试构造装饰器了。
装饰器的目的： 在不修改原函数(类)定义代码的情况下，增加新的功能
试想一下，现在有一个原函数
def original_function:
print("this is original function")
在不修改原函数定义代码的情况下，如果想进行函数内容的添加，可以将这个函数作为一个整体，添加到这样的包裹中：
def my_decorator(f):
def wrap_func():
print(f"before call {
f.__name__}")
f()
print(f"after call {
f.__name__}")
return wrap_func
new_function = my_decorator(original_function)
我们定义了一个my_decorator函数，这个函数进行了一种操作：
对传入的f，添加操作(运行前后增加打印)，并把添加操作后的内容连同运行原函数的内容，一起传出
这个my_decorator，定义了一种增加前后打印内容的行为
调用my_decorator时，对这个行为进行了操作。
因此，new_function是一个在original_function上增加了前后打印行为的新函数
这个过程被可以被称作装饰。
| 例子中的对象 | 角色 | 说明 |
|---|---|---|
| wrap | 闭包函数 | 重新定义了一种格式，这个格式可以任意的，是装饰器的真正内容 |
| my_decorator | 装饰器 | 定义了按warp这种格式进行操作的函数 |
| f | 待装饰函数(形参) | 在定义装饰器时，待装饰函数只是一个参数 |
| original_function | 实际进行装饰的函数 | 一个具体的需要装饰的函数 |
| new_function | 装饰后的函数 | 一个具体的装饰完成的函数 |
这里已经可以发现，装饰器本身对于被装饰的函数是什么，是不需要考虑的。装饰器本身只定义了一种装饰行为，这个行为是通过装饰器内部的闭包函数()进行定义的。
运行装饰前后的函数，可以清晰看到装饰的效果
def original_function():
print("this is original function")
def my_decorator(f):
def wrap_func():
print(f"before calling {
f.__name__}")
f()
print(f"after calling {
f.__name__}")
return wrap_func
new_function = my_decorator(original_function)
original_function()
print("#########")
new_function()
3装饰器定义的简写
我们复现一下实际要用装饰器的情况，我们往往有一种装饰器，想应用于很多个函数，比如
def my_decorator(f):
def wrap_func():
print(f"before calling {
f.__name__}")
f()
print(f"after calling {
f.__name__}")
return wrap_func
def print1():
print("num=1")
def print2():
print("num=2")
def print3():
print("num=3")
此时，如果我们想给3个print函数都加上装饰器，需要这么做
new_print1 = my_decorator(print1)
new_print2 = my_decorator(print2)
new_print3 = my_decorator(print3)
实际调用的时候，就需要调用添加装饰器的函数名了
new_print1()
new_print2()
new_print3()
当然，也可以赋值给原函数名
print1 = my_decorator(print1)
print1 = my_decorator(print2)
print3 = my_decorator(print3)
这样至少不需要管理一系列装饰前后的函数。
同时，在不需要进行装饰的时候，需要把
print1 = my_decorator(print1)
print1 = my_decorator(print2)
print3 = my_decorator(print3)
全部删掉。
事实上，这样并不方便，尤其对于更复杂的装饰器来说
为此，python提供了一种简写方式
def my_decorator(f):
def wrap_func():
print(f"before calling {
f.__name__}")
f()
print(f"after calling {
f.__name__}")
return wrap_func
@my_decorator
def print1():
print("num=1")
这个定义print1函数前的@my_decorator，相当于在定义完print1后，自动直接运行了
print1 = my_decorator(print1)
一个新的麻烦及解决办法
不论采用@my_decorator放在新函数前，还是显示地重写print1 = my_decorator(print1)，都会存在一个问题：
装饰后的函数，名字改变了(其实不止名字，一系列的索引都改变了)
def print1():
print("num=1")
print(f"before decorate, function name: {
print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {
print1.__name__}")
输出结果为:
before decorate, function name: print1 after decorate, function name: wrap_func
这个现象的原因是，装饰行为本身，是通过构造了一个新的函数（例子中是wrap_func函数）来实现装饰这个行为的，然后把这个修改后的函数赋给了原函数名。
这样，会导致我们预期的被装饰函数的一些系统变量（比如__name__）发生了变化。
对此，python提供了解决方案：
from functools import wraps # 导入一个系统工具
def my_decorator(f):
@wraps(f) # 在定义装饰行为函数的时候，增加一个新的装饰器
def wrap_func():
print(f"before calling {
f.__name__}")
f()
print(f"after calling {
f.__name__}")
return wrap_func
经过这个行为后，被装饰函数的系统变量问题被解决了
def print1():
print("num=1")
print(f"before decorate, function name: {
print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {
print1.__name__}")
输出结果为
before decorate, function name: print1 after decorate, function name: print1
当然，如果你不需要使用一些系统变量，也可以不关注这个问题。
复杂一点的情况1 被装饰函数有输入输出
刚才的例子都比较简单，被装饰的函数是没有参数的。如果被装饰的函数有参数，只需要在定义装饰行为时（事实上，这个才更通用），增加(*args, **kwargs)描述即可
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
print(f"before calling {
f.__name__}")
ret = f(*args, **kwargs) # 透传了输入参数，并记录了输出
print(f"after calling {
f.__name__}") # line-after
return ret # 执行 "line-after" 后，将f的输出返回
return wrap_func
之前的描述中可以感受到，对于例子中的装饰行为(前后加打印)，函数被装饰后，本质上是调用了新的装饰函数wrap_func。
因此，如果原函数需要有输入参数传递，只需要在wrap_func（或其他任意名字的装饰函数）定义时，也增加参数输入(*args, **kwargs)，并将这些参数，原封不动地传给待装饰函数f。
这种定义装饰行为的方式更具有普遍性，忘记之前的定义方式吧
我们试一下
@my_decorator
def my_add(x, y):
return x + y
n = my_add(1, 3)
print(n)
输出
before calling my_add after calling my_add 4
这里需要注意的是，如果按照以下的方式定义装饰器
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
print(f"before calling {
f.__name__}")
return f(*args, **kwargs) # 透传了输入参数，并记录了输出
print(f"after calling {
f.__name__}") # line-after
return wrap_func
那么以下语句将不会执行
print(f"after calling {
f.__name__}") # line-after
因为装饰后实际的函数wrap_func(虽然名字被改成了原函数，系统参数也改成了原函数)，运行到return f(*args, **kwargs) 的时候已经结束了
复杂一点的情况2 装饰器有输入
因为装饰器my_decorator本身也是可以输入的，因此，只需要在定义装饰器时，增加参数，并在后续函数中使用就可以了，比如
from functools import wraps
def my_decorator(f, msg=""):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
print(f"{
msg}, before calling {
f.__name__}")
return f(*args, **kwargs) # 透传了输入参数，并记录了输出
print(f"{
msg}, after calling {
f.__name__}") # line-after
return wrap_func
此时装饰器已经可以有输入参数了
def my_add(x, y):
return x + y
my_add = my_decorator(my_add, 'yusheng')
n = my_add(1, 3)
print(n)
输出
yusheng, before calling my_add yusheng, after calling my_add 4
你可能发现，为什么不用简写版的方法了
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
n = my_add(1, 3)
print(n)
因为以上代码会报错！！
究其原因，虽然
@my_decorator
def my_add(x, y):
return x + y
等价于
def my_add(x, y):
return x + y
my_add = my_decorator(my_add)
但是，
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
并不等价于
def my_add(x, y):
return x + y
my_add = my_decorator(my_add, msg='yusheng')
这本身和@语法有关，使用@my_decorator时，是系统在应用一个以单个函数作为参数的闭包函数。即，@是不能带参数的。
但是你应该发现了，之前的@wraps(f)不是带参数了吗？请仔细观察以下代码
def my_decorator_with_parma(msg='')
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
print(f"{
msg}, before calling {
f.__name__}")
return f(*args, **kwargs) # 透传了输入参数，并记录了输出
print(f"{
msg}, after calling {
f.__name__}") # line-after
return wrap_func
return my_decorator
通过一层嵌套，my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator)，但因为my_decorator对my_decorator_with_parma来说是一个闭包，my_decorator_with_parma是可以带参数的。（这句话真绕）
通过以上的定义，我们再来看
@my_decorator_with_parma(msg='yusheng')
def my_add(x, y):
return x + y
可以这么理解，my_decorator_with_parma(msg=‘yusheng’)的结果是原来的my_decorator函数，同时，因为my_decorator_with_parma可以传参，参数实际上是参与了my_decorator的（因为my_decorator对my_decorator_with_parma是闭包）， my_decorator_with_parma(msg=‘yusheng’) 全等于 一个有参数参加的my_decorator
因此，以上代码等价于有参数msg传递的
@my_decorator
def my_add(x, y):
return x + y
比较绕，需要理解一下，或者干脆强记这种范式：
from functools import wraps
def my_decorator(msg=''): # 名字改一下
def inner_decorator(f): # 名字改一下
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
print(f"{
msg}, before calling {
f.__name__}")
ret = f(*args, **kwargs) # 透传了输入参数，并记录了输出
print(f"{
msg}, after calling {
f.__name__}") # line-after
return ret
return wrap_func
return inner_decorator
以上范式包含函数的输入输出、装饰器的输入，可以应对大部分情况了。
实验一下：
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
my_add(1, 2)
输出
yusheng, before calling my_add yusheng, after calling my_add
有用的函数装饰器例子
统计耗时的日志
from functools import wraps
import datetime
def log(output_path=None): # 名字改一下
def decorator(f): # 名字改一下
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
now = datetime.datetime.now()
msg = now.strftime("%Y-%m-%d %H:%M:%S") # 运行时刻
msg += f" {
f.__name__}()\n" # 运行的函数名
ret = f(*args, **kwargs) # 透传了输入参数，并记录了输出
aft = datetime.datetime.now()
time_cost = aft - now
ms = time_cost.total_seconds() * 10**3 # 毫秒
msg += now.strftime("%Y-%m-%d %H:%M:%S")
msg += f" {
f.__name__}() return, cost {
ms} ms"
if output_path is None:
print(msg)
else:
print(f"print logs into {
output_path}")
with open(output_path, 'a+') as fp:
fp.write(msg + '\n')
return wrap_func
return decorator
以上是一个log装饰器，利用datetime统计了函数的耗时，
并且，装饰器可以进行输出文件操作，如果给出了文件路径，则输出文件，否则就打印。
利用这个装饰器，可以灵活地进行耗时统计
@log()
def my_sum(x, y):
s = 0
for i in range(x, y+1):
s += i
return s
my_sum(1, 9999999)
不设置输出文件地址，则打印。运行结果为：
2021-12-03 10:01:52 my_sum() 2021-12-03 10:01:52 my_sum() return, cost 506.3299999999999 ms
也可以输出到文件
@log('test.log')
def my_sum(x, y):
s = 0
for i in range(x, y+1):
s += i
return s
my_sum(1, 9999999)
输出结果为
print logs into test.log
同时在当前目录生成了一个test.log 文件，内容为：
2021-12-03 10:03:17 my_sum() 2021-12-03 10:03:17 my_sum() return, cost 461.813 ms
从装饰函数到装饰类
以上的装饰器都是以函数形式出现的，但我们可以稍做改写，将装饰器以类的形式实现。
from functools import wraps
import datetime
class Log:
def __init__(self, path=None):
self._output = path
def __call__(self, f): # 相当于原来的 inner_decorator
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了输入参数
now = datetime.datetime.now()
msg = now.strftime("%Y-%m-%d %H:%M:%S") # 运行时刻
msg += f" {
f.__name__}()\n" # 运行的函数名
ret = f(*args, **kwargs) # 透传了输入参数，并记录了输出
aft = datetime.datetime.now()
time_cost = aft - now
ms = time_cost.total_seconds() * 10**3 # 毫秒
msg += now.strftime("%Y-%m-%d %H:%M:%S")
msg += f" {
f.__name__}() return, cost {
ms} ms"
if self._output is None:
print(msg)
else:
print(f"print logs into {
self._output}")
with open(self._output, 'a+') as fp:
fp.write(msg + '\n')
return wrap_func
这个装饰器类Log 上个例子里的装饰器函数log功能是一样的，同时，这个装饰器类还可以作为基类被其他继承，进一步增加功能。