Python函数式编程指南（三）：迭代器

Python Generators(生成器)
 
 

生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。

生成器不仅“记住”了它数据状态；生成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。

生成器的特点：

     生成器是一个函数，而且函数的参数都会保留。

     迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的

在python中，yield就是这样的一个生成器。

yield 生成器的运行机制：

当你问生成器要一个数时，生成器会执行，直至出现 yield 语句，生成器把 

     yield 的参数给你，之后生成器就不会往下继续运行。 当你问他要下一个数时，他会从上次的状态。开始运行，直至出现yield语句，把参数给你，之后停下。如此反复 直至退出函数。（以上关于yield的描述，在后面列举一个简单的例子来解释这段话）

yield的使用：

在python中，当你定义一个函数，使用了yield关键字时，这个函数就是一个生成器，它的执行会和其他普通的函数有很多不同，函数返回的是一个对象，而不是你平常 所用return语句那样，能得到结果值。如果想取得值，那得调用next()函数，如：

 
 

   
   

    
    

   
   
   
   

    
    

     
     c = h() 
     
     #h()包含了yield关键字
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     #返回值
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     c.
     
     next()
    
    
   
   
 
 

每当调用一次迭代器的next函数，生成器函数运行到yield之处，返回yield后面的值且在这个地方暂停，所有的状态都会被保持住，直到下次next函数被调用，或者碰到异常循环退出。

下面，来看看以下的例子代码吧，是用来说明yield运行机制的。

 
 

   
   

    
    

   
   
   
   

    
    

     
     def fib(max):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         a, b = 
     
     1, 
     
     1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     while a < max:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     yield a 
     
     #generators return an iterator that returns a stream of values.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             a, b = b, a+b
    
    
   
   
 
 

程序运行：

 
 

   
   

    
    

   
   
   
   

    
    

     
     for n 
     
     in fib(
     
     15):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     print n
    
    
   
   
 
 

从前面的运行机制描述中，可以获知，程序运行到yield这行时，就不会继续往下执行。而是返回一个包含当前函数所有参数的状态的iterator对象。目的就是为了第二次被调用时，能够访问到函数所有的参数值都是第一次访问时的值，而不是重新赋值。

程序第一次调用时：

 
 

   
   

    
    

   
   
   
   

    
    

     
     def fib(max):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         a, b = 
     
     1, 
     
     1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     while a < max:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     yield a 
     
     #这时a,b值分别为1,1，当然，程序也在执行到这时，返回
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             a, b = b, a+b
    
    
   
   
 
 

程序第二次调用时：

从前面可知，第一次调用时，a,b=1,1，那么，我们第二次调用时（其实就是调用第一次返回的iterator对象的next()方法），程序跳到yield语句处，

执行a,b = b, a+b语句，此时值变为：a,b = 1, (1+1) => a,b = 1, 2

程序继续while循环，当然，再一次碰到了yield a 语句，也是像第一次那样，保存函数所有参数的状态，返回一个包含这些参数状态的iterator对象。

等待第三次的调用....

 
 

   
   

    
    

   
   
   
   

    
    

     
     def fib(max):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         a, b = 
     
     1, 
     
     1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     while a < max:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     yield a 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             a, b = b, a+b
    
    
   
   
 
 

通过上面的分析，可以一次类推的展示了yield的详细运行过程了！

通过使用生成器的语法，可以免去写迭代器类的繁琐代码，如，上面的例子使用迭代类来实现，代码如下：

 
 

   
   

    
    

   
   
   
   

    
    

     
     class Fib:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     def __init__(self, max):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     self.max = max
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     def __iter__(self):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     self.a = 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     self.b = 
     
     1
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return 
     
     self
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     def next(self):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             fib = 
     
     self.a
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     if fib > 
     
     self.
     
     max:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 raise StopIteration
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     self.a, 
     
     self.b = 
     
     self.b, 
     
     self.a + 
     
     self.b
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return fib
    
    
   
   
 
 

yield其他例子展示：排列，组合

#生成全排列    

 
 

   
   

    
    

   
   
   
   

    
    

     
     def perm(items, n = None):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     if n 
     
     is 
     
     None:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             n = len(items)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     for i 
     
     in range(len(items)):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             v = items[i:i+
     
     1]
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     if n==
     
     1:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     yield v
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     else:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 rest = items[:i] + items[i+
     
     1:]
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     for p 
     
     in perm(rest, n
     
     -1):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     yield v + p
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     def comb(items, n = None):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     if n 
     
     is 
     
     None:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             n = len(items)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     else:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     for i 
     
     in range(len(items)):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 v = items[i:i+
     
     1]
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     if 
     
     1 == n:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     yield v
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     else:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     rest = items[i+
     
     1:]
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     for c 
     
     in comb(rest, n
     
     -1):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                    
     
     yield v + c