pyhon学习有一段时间了，今天又碰到了Django的中间件，其实Django里面的中间件，就是用了多层的装饰器，然后去了解了一下多层装饰器，感觉有写东西差不多快忘了，也可能前面没学好。
现在重新记录，学习下。
普通简单装饰器
def warp(func):
print('我是装饰器，碰到需要装饰的函数，一开始执行这里')
def inner(*args, **kwargs):
print('这里才是真正的装饰开始！')
res = func(*args, **kwargs)
print('装饰结束')
return res
print('我这里是外围，先出去了，里面的等需要的时候执行')
return inner
@warp # 装饰器符号
def demo(x, y):
return x + y
if __name__ == '__main__':
demo(1, 2)
运行结果：
我是装饰器，碰到需要装饰的函数，一开始执行这里 我这里是外围，先出去了，里面的等需要的时候执行 这里才是真正的装饰开始！ 装饰结束
装饰器的本质就是一个函数，当你写好装饰器的函数从上而下运行时，一旦遇到@的提醒，python应该就开始进入准备状态寻找需要装饰的函数，当遇到下面一个需要被装饰的函数demo时，
整个过程我在debug过程中发现，其实python马上跳转到开始去执行了warp函数，这就是刚开始我们输出前面两句的原因，其实这个时候，程序根本没有执行到demo（1，2）的地方。
在这个warp 程序的运行过程中，还发生一个命名转换的过程，就是demo=warp(demo)，其实就是demo等于warp执行返回的函数inner，所以最后面执行demo(1，2)的时候，装饰器开始工作。
理解了这个，后面多层的装饰器更加好理解了。
简单来说，装饰器是一个可调用对象，但返回的还是一个可调用对象。
下面上一个最简单的两层装饰器。
def deco1(func):
print('func 1 in')
def wrapper1():
print('wrap1 in')
func()
print('wrap1 out')
print('func 1 out')
return wrapper1
def deco2(func):
print('func 2 in')
def wrapper2():
print('wrap2 in')
func()
print('wrap2 out')
print('func 2 out')
return wrapper2
@deco1
@deco2
def foo():
print('foo')
if __name__ == '__main__':
foo()
执行结果为：
func 2 in
func 2 out
func 1 in
func 1 out
wrap1 in
wrap2 in
foo
wrap2 out
wrap1 out
其实一开我因为没能理解装饰器的原理在两个地方卡住了，第一个就是为什么先出的是
func 2 in
func 2 out
func 1 in
func 1 out
第二个问题就是为什么foo函数执行了一次，第二问题，网上查到了资料，第一个问题，通过对装饰的理解和debug的过程，也理解了。
通过介绍，整个程序是至上而下运行的，在运行过程到
@deco1
@deco2
def foo():
一遇到需要装饰的函数def的时候，用要开始重新走装饰器，在走的过程中，先走跟函数近的装饰器deco2，所以输出了
func 2 in
func 2 out
再走deco1，所以输出了
func 1 in
func 1 out
回头来看就好理解多了，多层装饰，装饰器函数除了返回的内部函数不执行。函数体内会执行。就脚本执行的时候先执行foo=deco1(deco2(foo))
所以先执行了装饰函数内的print输出，当执行foo()函数的时候，
首先要执行deco1装饰器内的wrapper1()函数，当wrapper1()函数执行到func()的时候，会去执行deco2装饰器返回的wapper2函数，因为wrapper1内的func就是deco2装饰器中的wrapper2
wrapper2中的func位被装饰的函数foo。好心累。
最后一个带参数的装饰器。
这个更加像一个内部返回来两次函数的定义函数，一共需要三个def来写这个函数。
为什么需要三个def，很简单因为带参数的装饰器在@func()这样的时候，已经消耗了一个def。
def deco(params): # params 为需要传入的参数
print('floor1')
def inner(func):
print('floor2')
def warp(*args, **kwargs):
print('floor3')
print('装饰开始')
for i in range(params):
func(*args, **kwargs)
print('装饰结束')
print('out3')
print('out2')
return warp
print('out1')
return inner
@deco(5) #这个就是生成一个函数warp指向demo
def demo():
print('ok')
if __name__ == '__main__':
demo()
执行结果：
/Users/shijianzhong/Desktop/swiper/.venv/bin/python /Users/shijianzhong/Desktop/swiper/paramsfunc.py
floor1 out1 floor2 out2 floor3 装饰开始 ok ok ok ok ok 装饰结束 out3
三层装饰器，简单的理解就是一个装饰器工厂，运行@func()的时候，func()将返回一个装饰器给需要装饰的对象用。
带参数的装饰器，也可以用类写，参考链接：https://blog.csdn.net/weixin_43751803/article/details/86491529
class Decorate(object):
"""将最终返回的函数名更新为func原始函数名"""
def __init__(self, func):
print('装饰器初始化',func.__name__)
self.__func = func
self.__name__ = Decorate.__name__
@classmethod
def set_name(cls,update_func):
cls.__name__ = update_func.__name__
print(cls.__name__)
return cls
def __call__(self, *args, **kwargs):
print('装饰器功能')
self.__func(*args, **kwargs)
def decorater(func):
@Decorate.set_name(func)
def wrapping(*args,**kwargs):
print('执行函数',func.__name__)
return func(*args,**kwargs)
return wrapping
@decorater
def test(a,b):
print(a+b)
test(2,3)
print('返回的函数名',test.__name__)
作者对装饰器的理解还是蛮厉害的，通过类方法，给类添加一些属性，然后然后自己。
后期的返回的装饰器类，实例以后调用类属性，逻辑还是非常清晰可用的。