Python闭包（closures)的理解及分析

闭包（closures）这一概念在许多脚本语言，比如javascript，python，lua中普遍存在，对于长期用c/c++编程的程序员来讲，闭包的概念不是特别容易理解，也不清楚闭包的应用场景。确实，闭包的概念是面向过程编程的产物，其本质含义是一个函数和某个数据绑定在一起，数据的生命周期和函数的生命周期一样长。从上面这段话中，隐隐约约感觉到了什么？下面我们来看一下比较正式的闭包定义，并看一个简单的闭包例子。
python闭包定义：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).

  1 #!/usr/bin/env python
  2 
  3 def fun(m):
  4     def add(n):
  5         return m + n
  6     return add
  7 
  8 f1 = fun(10)
  9 print f1(1) #输出11
 10 print f1(2) #输出12
 11 print f1(3) #输出13
 12 
 13 f2 = fun(20)
 14 print f2(1) #输出21
 15 print f2(2) #输出22
 16 print f2(3) #输出23

闭包是定义在一个函数内部的函数，该函数引用了其外层函数的局部变量或型参变量，然后外层函数将闭包函数做为返回值返回。外面的调用方可以直接调用闭包体（比如上述代码中的f1），外层函数的局部变量（比如fun中的局部变量m）都不会消失，直到闭包体消亡。另外一个特点是定义不同的闭包体的时候，比如f1和f2，两者之间的局部变量是互相不干预的，是各自独立的一份。
根据上述例子，我们很容易将闭包跟C++的类、对象、成员函数、成员变量一一对应起来，闭包和面向对象的类本质上属于同一个思想的东西。为了说明这一点，我们举一个更加复杂的例子：
  1 #!/usr/bin/env python                                                     
  2 def fun(m):                                                               
  3     n = [1]                                                               
  4     def inc():                                                            
  5         k = m[0] + n[0]                                                   
  6         n[0] += 1                                                         
  7         m[0] += 1                                                         
  8         print k                                                           
  9         
 10     def sub():                                                            
 11         n[0] -= 1                                                         
 12         m[0] -= 1                                                         
 13     
 14     return inc, sub                                                       
 15         
 16 f_inc, f_sub = fun([2])                                                   
 17         
 18 times = 0
 19 while True:                                                               
 20     f_inc()                                                               
 21     times += 1
 22     if times == 10: break                                                 
 23         
 24 times = 0
 25 while True:                                                               
 26     f_sub()                                                               
 27     times += 1                                                            
 28     if times == 10: break                                                 
 29     
 30 times = 0                                                                 
 31 while True:                                                               
 32     f_inc()                                                               
 33     times += 1                                                            
 34     if times == 10: break          

fun函数返回两个闭包函数f_inc及f_sub，这两个闭包函数引用了fun里面的局部变量m及n。从面向对象的观点来看，可以将fun理解为一个类，f_inc及f_sub理解为类的成员函数，fun里面的局部变量m，n可以理解为类的成员变量。对于函数fun的调用，比如fun([2])，可以理解为类的实例化。从这些观点来理解闭包，就非常容易理解闭包的各种特性了。为了方便大家理解，大家可以参考下面这段c++代码，感觉闭包和C++的类、对象概念是不是完全一致？
  1 #include
  2 
  3 class CFun
  4 {
  5 public:
  6     CFun(int m)
  7     {
  8         _n = 1;
  9         _m = m;
 10     }
 11 
 12 public:
 13     void f_inc()
 14     {
 15         int k = _m + _n;
 16         _n++;
 17         _m++;
 18         printf("%d\r\n", k);
 19     }
 20 
 21     void f_sub()
 22     {
 23         _n--;
 24         _m--;
 25     }
 26 
 27 private:
 28     int _n;
 29     int _m;
 30 
 31 };
 33 int main()
 34 {
 35     CFun fun(2);
 36     int times = 0;
 37     while(times < 10)
 38     {
 39         fun.f_inc();
 40         times++;
 41     }
 42 
 43     times = 0;
 44     while(times < 10)
 45     {
 46         fun.f_sub();
 47         times++;
 48     }
 49 
 50     times = 0;
 51     while(times < 10)
 52     {
 53         fun.f_inc();
 54         times++;
 55     }
 56 
 57     return 0;
 58 }

根据闭包的特性，可以看出其比较适合用于回调函数。因为该回调函数天然和一堆数据绑定在一起，可以省去大量的数据存储、读取工作。试想一下再面向过程编程中，若没有闭包，在设计回调函数中必然有一块数据需要单独存储，在回调时再将这块数据找出来，然后塞给这个回调函数。有了闭包后再这块可以简单很多。但在面向对象编程中，闭包基本很难发挥什么特点，对于回调我们可以设计虚函数等方式来实现数据和函数的绑定。
下面再来简单分析一下闭包的实现，整个闭包的实现和脚本语言的内存回收机制是密不可分的。对于上面的例子，可以简单理解为当 f_inc, f_sub = fun([2]) 执行时，fun里面的局部变量都被开辟，且引用计数都变为了3（f_inc，f_sub，fun都取得了一个），当执行完时，虽然fun消亡，引用计数减一，但局部变量的引用计数依旧为2，不会被系统收回。当f_inc和f_sub被定义时，其作用域链已经被确定，如下图所示。当fun([2])被执行时，相当于确定了一个执行环境，作用域链上所有的变量都会被初始化。整个概念跟类的定义及类的实例化一模一样，因此采用面向对象的观念来理解闭包，就非常容易想清楚其背后的实现原理及应用场景。

参考资料：

http://blog.csdn.net/marty_fu/article/details/7679297