闭包是什么
在Python中，闭包Closure可以理解为函数以及函数所处的环境的一个整体。
下面的例子展示了一个最简单的闭包的示例：
def closure():
a = 1
def func(x):
return a + x
return func
f1 = closure()
f2 = closure()
print(f1(1)) # 结果为2
print(f1(2)) # 结果为3
但对内部函数稍作修改，尝试改变变量a的值时
def func(x):
a += 1
return a + x
return func
会发生如下错误
UnboundLocalError: local variable 'a' referenced before assignment，原因在于变量a为不可变类型，已经被引用了，python解释器会阻止这样的操作。
那么，尝试使用可变类型，再看看结果如何。
def closure():
a = []
def func(x):
a.append(x)
return a
return func
f1 = closure()
f2 = closure()
print(f1(1)) # 结果为[1]
print(f1(2)) # 结果为[1, 2]
print(f2(3)) # 结果为[3]
print(f2(4)) # 结果为[3, 4]
内部函数可以成功修改闭包区域的变量。
此外，创建了两个闭包的实例，通过结果可以看到，同一实例中闭包中的变量是共享的，而不同的闭包实例是不会相互影响的。
如果闭包区域中的变量为不可变类型，又想去改变它，可以使用nonlocal修饰该变量。
def closure():
a = 1
def func(x):
nonlocal a
a += x
return a
return func
装饰器
闭包最重要的应用，其实就是装饰器了。
最简单的装饰器
定义一个闭包函数，此函数接收一个参数，传入另一个函数名，在内部函数中调用传入的函数
def decorator(f):
def func():
print('decorator start...')
f()
print('decorator end...')
return func
def test():
print('test...')
if __name__ == '__main__':
my_test = decorator(test)
my_test()
这里显式地将test函数传入闭包函数decorator中，得到一个新的函数（实际上就是闭包函数中的内部函数func）。
而Python提供了语法糖，使用@decorator来修饰目标函数，使装饰器的使用更为方便。
def decorator(f):
def func():
print('decorator start...')
f()
print('decorator end...')
return func
@decorator
def test():
print('test...')
if __name__ == '__main__':
test()
多个装饰器的执行顺序
def decorator1(f):
def func():
print('decorator 1 start...')
f()
print('decorator 1 end...')
return func
def decorator2(f):
def func():
print('decorator 2 start...')
f()
print('decorator 2 end...')
return func
@decorator1
@decorator2
def test():
print('test...')
if __name__ == '__main__':
test()
执行结果如下
decorator 1 start...
decorator 2 start...
test...
decorator 2 end...
decorator 1 end...
从上面的结果看，可以理解为函数test首先被decorator2装饰后得到了一个中间函数，这个中间函数又被decorator1再次装饰。
目标函数(被装饰的函数)带参数
如果被装饰的函数带有参数，只需要在装饰器内部函数上添加相同个数参数即可。
def decorator(f):
def func(a, b):
print('decorator start...')
f(a, b)
print('decorator end...')
return func
@decorator
def test(a, b):
print('test...', a, b)
if __name__ == '__main__':
test(123, 456)
当然，除此以外，Python中的可变参数和关键字参数的特性能够使得这种场景变得更加通用。
对上面的代码稍作修改，这样目标函数不管有多少个参数都能在不修改装饰器函数的情况下支持了。
def decorator(f):
def func(*args, **kwargs):
print('decorator start...')
f(*args, **kwargs)
print('decorator end...')
return func
@decorator
def test(a, b, c):
print('test...', a, b, c)
if __name__ == '__main__':
test(123, 456, 789)
装饰器带参数
如果装饰器函数本身带有参数，该如何处理呢？
原来装饰器函数的参数为目标函数的函数名，现在装饰器函数本身有参数，那只需要将内部函数再包一层，用两次闭包就能解决问题。
def decorator(x, y):
def wrapper(f):
def func(*args, **kwargs):
print('装饰器参数：', x, y)
print('decorator start...')
f(*args, **kwargs)
print('decorator end...')
return func
return wrapper
@decorator(x=11, y=22)
def test(a, b):
print('test...', a, b)
if __name__ == '__main__':
test(33, 44)
通用装饰器
同样地，如果装饰器的参数不确定，那么使用可变参数及关键字参数，就能使的装饰器满足所有场景了。
def decorator(*ar, **kw):
def wrapper(f):
def func(*args, **kwargs):
print("装饰器参数:", ar, kw)
print('decorator start...')
f(*args, **kwargs)
print('decorator end...')
return func
return wrapper
@decorator(x='11', y='22')
def test(a, b):
print('test...', a, b)
if __name__ == '__main__':
test(33, 44)
类装饰器
前面的装饰器都是在说装饰器函数，其实类也作为装饰器，但前提是类中定义了call魔法函数，因为装饰器约定：接收一个callable对象，返回一个callable对象。
class Test:
def __init__(self, f):
print('Test inited..')
self.f = f
def __call__(self, *args, **kwargs):
print('Test called...')
self.f(*args, **kwargs)
@Test
def test(a, b):
print('test...', a, b)
if __name__ == '__main__':
test(1, 2)