认识Python中的闭包:闭包入门到自闭

本文首发于:行者AI

python中什么是闭包?闭包有什么用?为什么要用闭包?今天我们就带着这3个问题来一步一步认识闭包。

闭包和函数紧密联系在一起,介绍闭包前有必要先介绍一些背景知识,诸如嵌套函数、变量的作用域等概念。

1. 作用域

作用域是程序运行时变量可被访问的范围,定义在函数内的变量是局部变量,局部变量的作用范围只能是函数内部范围内,它不能在函数外引用。

定义在模块最外层的变量是全局变量,它是全局范围内可见的,当然在函数里面也可以读取到全局变量的。而在函数外部则不可以访问局部变量。例如:

a = 1 
def foo(): 
   print(a) # 1 
def foo(): 
    print(a) # NameError: name 'num' is not defined 

2. 嵌套函数

函数不仅可以定义在模块的最外层,还可以定义在另外一个函数的内部,像这种定义在函数里面的函数称之为嵌套函数(nested function)。对于嵌套函数,它可以访问到其外层作用域中声明的非局部(non-local)变量,比如代码示例中的变量a可以被嵌套函数printer 正常访问。

def foo(): 
   #foo是外围函数 
   a = 1 
   # printer是嵌套函数 
   def printer(): 
       print(a)
   printer() 
foo() # 1

那么有没有一种可能即使脱离了函数本身的作用范围,局部变量还可以被访问得到呢?

答案就是闭包!

我们将上述函数改成高阶函数(接受函数为参数,或者把函数作为结果返回的函数是高阶函数)的写法。

def foo(): 
   #foo是外围函数 
   a = 1 
   # printer是嵌套函数 
   def printer(): 
       print(a)
   return printer
x = foo() 
x() # 1

这段代码和前面例子的效果完全一样,同样输出 1。不同的地方在于内部函数 printer直接作为返回值返回了。

一般情况下,函数中的局部变量仅在函数的执行期间可用,一旦 foo() 执行过后,我们会认为变量a将不再可用。然而,在这里我们发现 foo 执行完之后,在调用x 的时候a变量的值正常输出了,这就是闭包的作用,闭包使得局部变量在函数外被访问成为可能。

3. 闭包

人们有时会把闭包和匿名函数弄混。这是有历史原因的:在函数内部定义函数 不常见,直到开始使用匿名函数才会这样做。而且,只有涉及嵌套函数时才有闭包问题。 因此,很多人是同时知道这两个概念的。

其实,闭包指延伸了作用域的函数,其中包含函数定义体中引用、但是不在定义体中定义的 非全局变量。函数是不是匿名的没有关系,关键是它能访问定义体之外定义的非全局变量。

通俗来讲闭包,顾名思义,就是一个封闭的包裹,里面包裹着自由变量,就像在类里面定义的属性值一样,自由变量的可见范围随同包裹,哪里可以访问到这个包裹,哪里就可以访问到这个自由变量。 那这个包裹是绑定在哪的呢?在上文代码追加一句打印:

  def foo():
       # foo是外围函数
       a = 1
       # printer是嵌套函数
       def printer():
           print(a)
       return printer
x = foo()
print(x.__closure__[0].cell_contents) # 1 

可以发现是在函数对象的__closure__属性中,__closure__是一个元祖对象函数负责闭包绑定,即自由变量的绑定。该属性值通常是None,如果这个函数是一个闭包的话,那么它返回的是一个由cell 对象组成的元组对象。cell 对象的cell_contents 属性就是闭包中的自由变量。这解释了为什么局部变量脱离函数之后,还可以在函数之外被访问的原因的,因为它存储在了闭包的 cell_contents中了。

4. 闭包的好处

闭包避免了使用全局变量,此外,闭包允许将函数与其所操作的某些数据(环境)关连起来。这一点与面向对象编程是非常类似的,在面对象编程中,对象允许我们将某些数据(对象的属性)与一个或者多个方法相关联。

一般来说,当对象中只有一个方法时,这时使用闭包是更好的选择。来看一个计算均值的例子,假如有个名为avg 的函数,它的作用是计算不断增加的系列值的均值;例如,整个历史中 某个商品的平均收盘价。每天都会增加新价格,因此平均值要考虑至目前为止所有的价格,如下所示:

>>> avg(10) #10.0 
>>> avg(11) #10.5 
>>> avg(12) #11.0 

在以往,我们可以设计一个类:

class Averager():

def __init__(self):
   self.series = []
    
def __call__(self, new_value):
   self.series.append(new_value)
   total = sum(self.series)
   return total/len(self.series)
   
avg = Averager()
avg(10) #10.0
avg(11) #10.5
avg(12) #11.0

这时候我们使用闭包来实现。

def make_averager():
   series = []
   def averager(new_value):
       series.append(new_value)
       total = sum(series)
       return total/len(series)
   return averager

avg = make_averager()
avg(10) #10.0
avg(11) #10.5
avg(12) #11.0

调用make_averager 时,返回一个 averager 函数对象。每次调用 averager 时,它会把参数添加到列表中,然后计算当前平均值。 这比用类来实现更优雅,此外装饰器也是基于闭包的一中应用场景。

5. 闭包的坑

看了上述闭包的解释你以为闭包也不过如此?实际使用中往往在不经意间就会掉入陷阱,看看下面的例子:

def create_multipliers():
   return [lambda x: x * i for i in range(5)]
    
for multiplier in create_multipliers():
   print(multiplier(2))
    
# 期望输出0, 2, 4, 6, 8
# 结果是 8, 8, 8, 8, 8

我们期望是输出0, 2, 4, 6, 8。结果却是8, 8, 8, 8, 8。为什么会出现这问题呢?让我们改下代码:

def create_multipliers():
   multipliers = [lambda x: x * i for i in range(5)]
   print([m.__closure__[0].cell_contents for m in multipliers])
        
create_multipliers()  # [4, 4, 4, 4, 4] 

可以看到函数绑定的i值都成了4即循环后最终i的取值,这是因为Python的闭包是延迟绑定 ,这意味着闭包中用到的变量的值,是在内部函数被调用时查询得到的。

正确的使用方式是将i的值利用参数的方式进行传递:

def create_multipliers():
   return [lambda x,i=i: x * i for i in range(5)]
 
s = create_multipliers()
for multiplier in s:
   print(multiplier(2))  # 0, 2, 4, 6, 8

我们利用默认参数来传递i,同闭包一样默认参数是绑定在__defaults__属性上。

print([f.__defaults__ for f in s]) # [(0,), (1,), (2,), (3,), (4,)] 

你可能感兴趣的:(认识Python中的闭包:闭包入门到自闭)