理解闭包
装饰器的本质也是一个闭包，通俗理解就是执行一个函数，返回的仍然是函数
首先理解一下下面两段代码
# 第一段代码
def func():
print("我是 func 函数")
return [1, 2, 3]
res = func()
print(res)
# 第二段代码
def outer(fun):
def inner():
return fun()
return inner
f = outer(func) # 这里获取的其实是 inner() 函数，f 是一个函数
print(f()) # 这里是真正执行了 inner() 函数
上面两段代码输出是一样的，第二段代码其实就是一个闭包。
理解装饰器
上述两段代码结果相同，但是从调用函数的角度看，使用闭包，能让你的程序更加通用。
案例： 现在有 a、b、c 三个函数需要被调用，别求要求调用前输出日志，显示当前被调用的函数名称
三个函数如下：
def a():
return "a 函数"
def b():
return "b 函数"
def c():
return "c 函数"
最简单的想法，直接在每一个函数加上 print() 函数
代码1
def a():
print("现在执行的是 a 函数")
return "a 函数"
def b():
print("现在执行的是 b 函数")
return "b 函数"
def c():
print("现在执行的是 c 函数")
return "c 函数"
print(a())
print(b())
print(c())
"""输出结果
现在执行的是 a 函数
a 函数
现在执行的是 b 函数
b 函数
现在执行的是 c 函数
c 函数
"""
很显然，这不够好，因为你需要修改原函数。使用闭包在外层函数做修改，这样内层函数通过传参的方式传入，就不会受到影响。例如下方代码,输出和上面一致，但是并没有修改 a、b、c 三个函数的本身，而且调用方法很通用
代码2
def a():
return "a 函数"
def b():
return "b 函数"
def c():
return "c 函数"
def logger(fun):
print("当前执行的是 %s 函数" % fun.__name__)
def inner():
return fun()
return inner
f = logger(a)
print(f())
f = logger(b)
print(f())
f = logger(c)
print(f())
"""输出结果
现在执行的是 a 函数
a 函数
现在执行的是 b 函数
b 函数
现在执行的是 c 函数
c 函数
"""
代码2应该相对较好些，但是每次执行，都需要先执行f = logger(a) ，在执行 f() 也比较麻烦，后续就出现了装饰器来简化代码，在代码2的基础上，使用装饰器优化代码
代码3
def logger(fun):
print("当前执行的是 %s 函数" % fun.__name__)
def inner():
return fun()
return inner
@logger
def a():
return "a 函数"
print(a())
@logger
def b():
return "b 函数"
print(b())
@logger
def c():
return "c 函数"
print(c())
在函数a 上加 @logger 这是语法糖操作，他的作用其实就是把函数a当做参数，传递给 logger() 函数，后续执行原理就和上方的闭包一样了
在此基础上，继续优化，如果函数 a 需要传入参数了，上面的方法就不能用了，例如 a函数如下
def a(a, b):
return "a 函数传入的参数为: (%s %s)" % (a, b)
此时其实只需要将内层函数inner 函数改为接受任意参数即可，也不会影响其他函数
def logger(fun):
print("当前执行的是 %s 函数" % fun.__name__)
def inner(*args, **kwargs):
return fun(*args, **kwargs)
return inner
@logger
def a(a, b):
return "a 函数传入的参数为: (%s %s)" % (a, b)
print(a("a", "aa"))
@logger
def b():
return "b 函数"
print(b())
@logger
def c():
return "c 函数"
print(c())
"""输出结果
当前执行的是 a 函数
a 函数传入的参数为: (a aa)
当前执行的是 b 函数
b 函数
当前执行的是 c 函数
c 函数
"""
装饰器进阶
上述案例都是简单的装饰器，现实中我们经常见到 @logger(*args, **kwards) 这样的装饰器，这样的装饰器函数，可能需要三层及以上的闭包函数，第一层用来传递参数，下方案例来自某公司的面试题
案例： 实现一个装饰器，让执行失败的函数重试 n 次，n是动态传入 ，形如 @try_func(5)
# 让执行失败的函数重试n 次
def try_func(try_count):
print("需要重试 %s 次" % try_count)
def wrapper(func):
def inner(*args, **kwargs):
i = 1
res = None
while i <= try_count:
print("当前执行的是第%s次" % i)
try:
res = func(*args, **kwargs)
# 执行成功就直接跳出循环即可
break
except Exception as e:
i += 1
print("装饰器中打印函数报错日志：%s" % e)
return res
return inner
return wrapper
@try_func(3)
def test():
raise Exception("随便返回一个异常")
print(test())
"""执行结果
需要重试 3 次
当前执行的是第1次
装饰器中打印函数报错日志：随便返回一个异常
当前执行的是第2次
装饰器中打印函数报错日志：随便返回一个异常
当前执行的是第3次
装饰器中打印函数报错日志：随便返回一个异常
None
"""
装饰器函数需要传参的时候，需要三层闭包函数，最外层负责把参数传递进来
