python闭包

1.闭包的概念

闭包函数必须有内嵌函数

内嵌函数需要引用该嵌套函数上一级namespace中的变量

闭包函数必须返回内嵌函数

2.

闭包（closure）是函数式编程的重要的语法结构，Python也支持这一特性，下面就开始介绍Python中的闭包。

首先看看闭包的概念：闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，闭包是由函数和与其相关的引用环境组合而成的实体。

在开始介绍闭包之前先看看Python中的namespace。

2.1python中的namespace

Python中通过提供 namespace 来实现重名函数/方法、变量等信息的识别，其一共有三种 namespace，分别为：

• local namespace: 作用范围为当前函数或者类方法
• global namespace: 作用范围为当前模块
• build-in namespace: 作用范围为所有模块

当函数/方法、变量等信息发生重名时，Python会按照 “local namespace -> global namespace -> build-in namespace”的顺序搜索用户所需元素，并且以第一个找到此元素的 namespace 为准。

同时，Python中的内建函数locals()和globals()可以用来查看不同namespace中定义的元素。

例子：

s = "string in global"
num = 99
 
def numFunc(a, b):
    num = 100
    print "print s in numFunc: ", s
 
    def addFunc(a, b):
        s = "string in addFunc"
        print "print s in addFunc: ", s
        print "print num in addFunc: ", num
        print "locals of addFunc: ", locals()
        print 
        return "%d + %d = %d" %(a, b, a + b)
 
    print "locals of numFunc: ", locals()
    print 
    return addFunc(a, b)
 
numFunc(3, 6)    
print "globals: ", globals()

运行结果（对比程序的执行过程，了解闭包的执行）

('print s in numFunc:', 'string in global')
('locals of numFunc:', {'a': 3, 'b': 6, 'addFunc': <function addFunc at 0x0000000005535F28>, 'num': 100})

('print s in addFunc:', 'sting in addFunc')
('print num in addFunc:', 100)
('locals of addfunc:', {'a': 3, 's': 'sting in addFunc', 'b': 6, 'num': 100})

('globals:', {'numFunc': <function numFunc at 0x0000000004DDC518>, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:\\java\xd4\xb4\xce\xc4\xbc\xfe\\A\\BIBao.py', '__package__': None, 's': 'string in global', 'num': 99, '__name__': '__main__', '__doc__': None})

代码中通过locals()和globals()获取了不同namespace中定义的元素，当在”numFunc”函数中访问s变量的时候，由于local namespace中没有定义s，所以会找到global中的s；但是，由于”addFunc”的local namespace中有s，所以可以直接使用。

Python创建闭包

下面通过一个例子一步一步分析一下Python如何实现闭包。

一个闭包的例子

下面看一个闭包的简单的例子，例子中定义了一个可以配置打招呼的函数”greeting_conf”，在这个函数中，内嵌了一个”greeting”的内嵌函数：

def greeting_conf(prefix):
    def greeting(name):
        print prefix, name
    return greeting
 
mGreeting = greeting_conf("Good Morning")
mGreeting("Wilber")
mGreeting("Will")
 
print
 
aGreeting = greeting_conf("Good Afternoon")    
aGreeting("Wilber")
aGreeting("Will")

运行结果：

 

 

 

Python 中的闭包

 

闭包（closure）是函数式编程的重要的语法结构，Python也支持这一特性，下面就开始介绍Python中的闭包。

首先看看闭包的概念：闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，闭包是由函数和与其相关的引用环境组合而成的实体。

在开始介绍闭包之前先看看Python中的namespace。

Python中的namespace

Python中通过提供 namespace 来实现重名函数/方法、变量等信息的识别，其一共有三种 namespace，分别为：

• local namespace: 作用范围为当前函数或者类方法
• global namespace: 作用范围为当前模块
• build-in namespace: 作用范围为所有模块

当函数/方法、变量等信息发生重名时，Python会按照 “local namespace -> global namespace -> build-in namespace”的顺序搜索用户所需元素，并且以第一个找到此元素的 namespace 为准。

同时，Python中的内建函数locals()和globals()可以用来查看不同namespace中定义的元素。

看一个例子：

 

 

 

 

 

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

s = "string in global" num = 99   def numFunc(a, b):     num = 100     print "print s in numFunc: ", s       def addFunc(a, b):         s = "string in addFunc"         print "print s in addFunc: ", s         print "print num in addFunc: ", num         print "locals of addFunc: ", locals()         print         return "%d + %d = %d" %(a, b, a + b)       print "locals of numFunc: ", locals()     print     return addFunc(a, b)   numFunc(3, 6)     print "globals: ", globals()

上面代码的结果为：

代码中通过locals()和globals()获取了不同namespace中定义的元素，当在”numFunc”函数中访问s变量的时候，由于local namespace中没有定义s，所以会找到global中的s；但是，由于”addFunc”的local namespace中有s，所以可以直接使用。

Python创建闭包

下面通过一个例子一步一步分析一下Python如何实现闭包。

一个闭包的例子

下面看一个闭包的简单的例子，例子中定义了一个可以配置打招呼的函数”greeting_conf”，在这个函数中，内嵌了一个”greeting”的内嵌函数：

 

 

 

 

 

Python

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def greeting_conf(prefix):     def greeting(name):         print prefix, name     return greeting   mGreeting = greeting_conf("Good Morning") mGreeting("Wilber") mGreeting("Will")   print   aGreeting = greeting_conf("Good Afternoon")     aGreeting("Wilber") aGreeting("Will")

代码的结果为：

上面的代码有下面几个注意点：

1. “greeting”函数访问了non-local的变量”prefix”，根据前面namespace的介绍，这点是完全合法的
2. 变量”prefix”并没有随着函数的退出而销毁，反而是生命周期得到了延长

下面看看为什么变量”prefix”生命周期得到了延长？

__closure__属性

在Python中，函数对象有一个__closure__属性，我们可以通过这个属性看看闭包的一些细节。

def greeting_conf(prefix):
    def greeting(name):
        print prefix, name
    return greeting
 
mGreeting = greeting_conf("Good Morning")      
 
print dir(mGreeting)
print mGreeting.__closure__
print type(mGreeting.__closure__[0])
print mGreeting.__closure__[0].cell_contents

通过__closure__属性看到，它对应了一个tuple，tuple的内部包含了cell类型的对象。

对于这个例子，可以得到cell的值（内容）为”Good Morning”，也就是变量”prefix”的值。

从这里可以看到闭包的原理，当内嵌函数引用了包含它的函数（enclosing function）中的变量后，这些变量会被保存在enclosing function的__closure__属性中，成为enclosing function本身的一部分；也就是说，这些变量的生命周期会和enclosing function一样。

闭包和函数

闭包只是在表现形式上跟函数类似，但实际上不是函数。

def greeting_conf(prefix):
    def greeting(name):
        print prefix, name
    return greeting
 
mGreeting = greeting_conf("Good Morning")      
print "function name is:", mGreeting.__name__
print "id of mGreeting is:", id(mGreeting)
 
print
 
aGreeting = greeting_conf("Good Afternoon")  
print "function name is:", aGreeting.__name__
print "id of aGreeting is:", id(aGreeting)

从代码的结果中可以看到，闭包在运行时可以有多个实例，不同的引用环境（这里就是prefix变量）和相同的函数（这里就是greeting）组合可以产生不同的实例。