一.什么是闭包
不同编程语言实现闭包的方式是不同的,python中闭包从表现形式上看,如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure)。
举个例子:
def outer(x):
def inner(y):
return x + y
return inner
结合这段简单的代码和定义来说明闭包:
inner(y)就是这个内部函数,对在外部作用域(但不是在全局作用域)的变量进行引用:x就是被引用的变量,x在外部作用域outer里面,但不在全局作用域里,则这个内部函数inner就是一个闭包。
再稍微讲究一点的解释是,闭包=函数块+定义函数时的环境,inner就是函数块,x就是环境,当然这个环境可以有很多,不止一个简单的x。
在函数outer中定义了一个inner函数,inner函数访问外部函数outer的(参数)变量,并且把inner函数作为返回值返回给outer函数。
二:闭包的作用
闭包也就是装饰器的实现,其作用在于:
1、不改变原函数内代码段;
2、不改变原函数名称;
3、为原函数增加新的功能,改变输出结果等等。
本文涉及到以下3个知识点:
1、作用域LEGB法则(知道的可以跳过)
2、闭包
3、装饰器1、作用域LEGB法则
搜索变量名的作用域优先级:L局部 > E嵌套 > G全局 > B内置
L局部(local):def构建函数段中,定义的变量
E嵌套(enclosing):当前域该变量名无赋值操作,引用父级;反之引用当前
G全局(global):不在任何函数段内,写在所有函数外边,最外层的变量
B内置(built-in):系统__builtin__模块中的变量
L和G不用说了,局部和全局,就是函数里和函数外。
B内置,也不提了,一般碰不到。
主要说说E
def fa():
a = 0
def fb():
print(a)
fb()
fa()
fa()嵌套fb(),子函数中没有对变量a进行赋值操作,也是a=xxx之类的。所以在fb()的L中没有的时候,可以向上层也就是父级寻找,使用E作用域的中的变量。
假设这里改了一句
def fa():
a = 0
def fb():
print(a)
a = 1 # 这里加一句对a的赋值
fb()
fa()
# 输出结果
Traceback (most recent call last):
File "test.py", line 5, in fb
print(a)
UnboundLocalError: local variable 'a' referenced before assignment
你会发现在print(a)的时候,就出现了a未定义的错误。原因在于fb()的L局部作用域中,有对a进行了赋值这样的操作,a不能使用父级的定义。而在打印输出时,局部函数中a尚未定义,导致程序报错。
那么局部就不可以修改父级了么?其实是可以的。
原理和global声明变量,局部变全局是一个道理。
def fa():
a = 0
def fb():
nonlocal a
print(a)
a = 1
fb()
fa()
使用nonlocal声明后,a的作用域就扩展到了父级,就又可以使用E嵌套作用域了。
2、闭包说明
首先以一段闭包实现的代码为例:
def fa():
a = 0
def fb():
nonlocal a
print(a)
a = 1
return fb
f = fa()
f()
f()
# 输出结果
0
1
将闭包函数,之前的嵌套函数对比
发现代码基本一致,只有最后的fb()变成了return fb
def fa(): # def fa():
a = 0 # a = 0
def fb(): # def fb():
nonlocal a # nonlocal a
print(a) # print(a)
a = 1 # a = 1
return fb # fb()
这就导致程序没有执行内部函数fb,而是将内部函数打包作为输出。(闭包执行流程可以看当前页最下方的测试记录)
所以通过f = fa()返回的函数对象f,其实执行的是,打包好的内部函数fb()的内容,就是下面这段
def fb():
nonlocal a
print(a)
a = 1
但它的特别之处在于:
f创建时所携带的父层变量a会一直存在于内存中,不会因为函数执行完成而消失(除非你主动del f删掉)
f = fa()
f()
f()
# 输出结果
0
1
其结果分别为0和1的原因在于:
第1次f(),读取了f初始化时的a值进行输出为0,然后通过a=1,a才变成1
第2次f(),因为a已经变成1,所以a值输出为1,然后通过a=1,a依旧是1
其创建特征在于:函数嵌套,返回函数对象,返回那个函数引用了父层变量。
其使用特征在于:保存局部信息不被销毁。
三、装饰器说明
说完了闭包,来说装饰器。
首先写一个闭包程序,
函数funca将输入参数+1,作为结果输出。
闭包实现的是任意输入函数,将其输出结果求平方。
所以将funca打包成new_funca后,输出结果变成了(1+1)2=4
def build_bibao(f):
def bibao(*args):
result = f(*args)
return result**2
return bibao
def funca(num):
return num+1
new_funca = build_bibao(funca)
print(new_funca(1))
# 输出结果
4
那么将上面代码用@简写,其实就是装饰器的实现。
def build_bibao(f):
def bibao(*args):
result = f(*args)
return result**2
return bibao
@build_bibao
def funca(num):
return num+1
print(funca(1))
# 输出结果
4
装饰器实际上对输入函数funca做了包装,然后给你返回了包装好的,附加了新功能(结果求平方)的funca
============================================================
下面是自己研究闭包时候,做的一些测试(只做记录,可以忽略)
代码如下:
def funx(x):
return x*x
def build_bibao(func):
def bibao(j):
return func(j)
return bibao
new_funx = build_bibao(funx)
new_funx(5)
添加打印输出,确认其执行过程:
def funx(x):
return x*x
def build_bibao(func):
print(0,type(func),func)
def bibao(j):
print(3,type(j),j)
print(4,type(func.__name__),func.__name__)
print(5,type(func(j)),func(j))
return func(j)
print(1,type(bibao),bibao)
return bibao
new_funx = build_bibao(funx)
print(2,type(new_funx),new_funx)
new_funx(5)
可以依照打印序号,确认执行顺序和结果
0 <class 'function'> <function funx at 0x000002AA4EA72EA0>
1 <class 'function'> <function build_bibao.<locals>.bibao at 0x000002AA4EDD8730>
2 <class 'function'> <function build_bibao.<locals>.bibao at 0x000002AA4EDD8730>
3 <class 'int'> 5
4 <class 'str'> funx
5 <class 'int'> 25
[Finished in 0.2s]