Python装饰器

文章目录

Python装饰器
- 基本概念
- 从零开始的逐步分析
- 修饰后的问题
- 向被包装后的函数传递参数
- 使用场景：stdout日志
- 接受参数的装饰器
- 作为一个类的装饰器
- 总结

学习资料：

Python 函数装饰器
装饰器类
Python __call__()方法（详解版）

基本概念

先建立一个观点：
函数本质上是一个对象，可以赋值给其他变量
加上()后就变成执行函数本身，并获得其返回值

修改其他函数功能的函数，即是装饰器

因为它要修改其他函数，所以装饰器本身应该返回一个函数
从而将这个修改后的函数赋值给原函数，以达到修改原函数功能的目的

从零开始的逐步分析

首先是一个原型理解
主要理解函数本身是一个对象
可以赋值给其他变量，或是本身作为参数

def deco_func(func):print("doing", func.__name__)func()def hi():print("hi")deco_func(hi)

上述代码的函数hi不能接受参数
即如果变成这样子，则会报错：

def deco_func(func):print("doing", func.__name__)func()def hi(name):print("hi", name)deco_func(hi("Archeri"))

输出：

hi Archeri
Traceback (most recent call last):File "D:\python_work\guide\deco.py", line 8, in <module>deco_func(hi("Archeri"))File "D:\python_work\guide\deco.py", line 2, in deco_funcprint("doing", func.__name__)
AttributeError: 'NoneType' object has no attribute '__name__'. Did you mean: '__ne__'?

上面的代码，会先执行hi("Archeri")，然后执行deco_func函数
因为hi函数加上了()因此变成了执行函数本身，并取得其返回值
由于hi函数没有任何返回值，或者说返回NoneType
因此报错信息最后面提醒说
'NoneType' object has no attribute '__name__'.
合情合理

为了可以给内函数传递参数，则可能需要在外函数里定义一个新的函数去返回

简单的剖析代码：

# 装饰器，就是一个函数，接收要修饰的原函数
# 这个deco_func整体就是一个装饰器
def deco_func(func):# 因为要返回一个函数，所以在函数里面定义一个新的函数来返回# 这个函数用于在执行原函数前后，执行一些操作def wrap_func():print("doing", func.__name__)func()# 返回“修改”了原函数功能的，内部新定义的函数return wrap_func# 原函数
def hi():print("hi")# 执行原函数，看看原功能
hi()
#outputs: hi# ↓↓↓装饰器起作用的原理就在这里↓↓↓
# 装饰好原函数之后，将修改后的函数返回给原函数
hi = deco_func(hi)
#now hi is wrapped by wrap_func()# 检验装饰结果
hi()
#outputs:doing hi
#        hi

使用“@”的等效装饰效果：

# 装饰器，就是一个函数，接收要修饰的原函数
# 这个deco_func整体就是一个装饰器
def deco_func(func):# 因为要返回一个函数，所以在函数里面定义一个新的函数来返回# 这个函数用于在执行原函数前后，执行一些操作def wrap_func():print("doing", func.__name__)func()# 返回“修改”了原函数功能的，内部新定义的函数return wrap_func# 原函数，使用“@”装饰
@deco_func
def hi():print("hi")# 检验装饰结果
hi()
#outputs:doing hi
#        hi# 函数定义时使用“@”装饰
# 实际上就是下面这个展示装饰原理的语句：
# hi = deco_func(hi)

以上就是装饰器最基本的理解

修饰后的问题

但是上面使用“@”修饰函数之后
print(hi.__name__)会输出wrap_func
即hi函数的一些属性变了
是因为此时hi函数相当于承接了deco_func的返回值，相当于是wrap_func函数
因此hi此时更像是一个“变量”而不是“函数”
hi.__name__输出的指代返回的wrap_func

Python为上面的问题提供了一个原生又简单的解决方法：

from functools import wrapsdef deco_func(func):@wraps(func)def wrap_func():print("doing", func.__name__)func()return wrap_func

即导入wraps，然后在装饰器返回的函数前面用它来装饰即可
@wraps(func)

@wrap接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。
这可以让我们在装饰器里面访问在装饰之前的函数的属性。

向被包装后的函数传递参数

下面为了自己方便理解，作以下定义：
deco_func函数：装饰器
wrap_func函数：装饰器的返回结果，称为包装函数

若想给被装饰函数传入参数
则在包装函数原型中添加所有可变参数，并且在传给内部调用的被包装函数

from functools import wrapsdef deco_func(func):# 下面只是在定义函数，不执行其中的过程@wraps(func)def wrap_func(*args, **kw):print("doing", func.__name__)func(*args, **kw)# 最后返回定义好的函数，没有执行它return wrap_func@deco_func
def hi(name):print("hi", name)hi("Archeri")
#output: doing hi
#        hi Archeri

使用场景：stdout日志

from functools import wrapsdef logit(func):@wraps(func)def wrap_func(*args, **kw):print("doing", func.__name__)return func(*args, **kw)return wrap_func@logit
def my_add(x, y):return x + y@logit
def my_dec(x, y):return x - yprint(my_add(1, 1))
print(my_dec(1, 1))

output：

doing my_add
2
doing my_dec
0

接受参数的装饰器

上述装饰器虽然能装饰不同的函数
但是“装饰”这一行为本身是一样的
就好像一种啤酒，能装在任何杯子里
但装的量都是一样的
不能根据具体杯子的大小去变化装入的多少

因此可以给装饰器加上除被装饰函数之外的参数
来使装饰器的装饰行为变得可变、灵活

像是上面的日志场景，只能规定日志输出在stdout
下面就给装饰器添加参数，能够选择输出位置

一开始我是这样写装饰器的

def logit(func, logfile):@wraps(func)def wrap_func(*args, **kw):with open(logfile, 'a') as log_obj:log_obj.write("doing " + func.__name__)return func(*args, **kw)return wrap_func

想着直接在装饰器原型里加上除被装饰函数外的另一个参数
但是当使用@去装饰my_add函数时，传参遇到了问题

一开始@logit("addlog")，但是提示logit() missing 1 required positional argument: 'logfile'，说明这个日志文件参数给到了func

然后试试@logit(logfile="addlog")，但是又提示缺失参数func

好嘛，@logit(func=my_add, logfile="addlog")，就说我my_add未定义了

说明上面那个带参数的装饰器的写法是有问题的

之后看了看正确的写法
下面就是我的分析和猜测

上面的装饰器，用@装饰时使用了()
是不是意味着实际的装饰器变成了logit函数执行后的返回结果
即是wrap_func？
也就是说@logit()=@wrap_func？

看了看正确写法，为此又加多了一层函数去封装？

from functools import wraps# 最外层接受装饰器的参数
def logit(logfile):# 因为使用“@”装饰时要加圆括号传参，所以最外层应该返回真正的装饰器def log_deco(func):# 真正的装饰器，返回装饰后的原函数@wraps(func)def wrap_func(*args, **kw):with open(logfile, 'a') as log_obj:log_obj.write("doing "+func.__name__+'\n')return func(*args, **kw)return wrap_funcreturn log_deco

测试：

@logit("addlog")
def my_add(x, y):return x + y@logit("declog")
def my_dec(x, y):return x - yprint(my_add(1, 1))
print(my_dec(1, 1))

结果输出“2”、“0”
然后也各自生成了正确的日志文件，写入了正确的内容

作为一个类的装饰器

上面涉及到的装饰器，本质上都是一个函数（普通装饰器）
而实际上装饰器本身也可以是一个类（装饰器类）

例如上面的不带参数的装饰器，可以这样把它写成一个类：

class logit:# 初始化工作def __init__(self, func):self.func = func# __call__方法使得类可像函数那样去加上()调用# 类似于之前的warp函数def __call__(self, *args, **kw):print("doing", self.func.__name__)return self.func(*args, **kw)

普通的装饰方法：

my_add = logit(my_add)
# 之后的my_add变成了一个logit类的实例
print(my_add(1,1))
#output: doing my_add
#        2

上面等价于print(logit(my_add)(1, 1))
输出也是一样的

使用@的装饰方法：

@logit
def my_add(x, y):return x + yprint(my_add(1,1))
# 输出同上面一致
# 装饰后的my_add也变成了logit类的一个实例

下面是接受参数的动态装饰器类的写法：

from functools import wrapsclass logit:# 因为是在这个类初始化时传入的参数# 所以应该在__init__方法里准备好装饰器要用的参数def __init__(self, logfile):self.logfile = logfile# 因为初始化时使用()去传入装饰器参数# 后面需要再调用一次才能执行这个__call__# 因此在这里使用被装饰的函数def __call__(self, func):# 返回被装饰后的原函数# 只定义，不执行@wraps(func)def wrap_func(*args, **kw):with open(self.logfile, "a") as log_obj:log_obj.write("doing "+func.__name__+'\n')return func(*args, **kw)return wrap_func

普通的装饰方法：

def my_add(x, y):return x + y
my_add = logit("addlog")(my_add)
print(my_add(1, 1))
# 输出2，生成日志文件

使用@的装饰方法：

@logit("addlog")
def my_add(x, y):return x + y
print(my_add(1, 1))
# 输出2，生成日志文件

总结

装饰器类比普通装饰器具有更好的可读性

听说还要知道什么闭包的概念
会更好理解一点
先放着，会用就行