Python 迭代器和生成器

迭代器 
迭代器只不过是一个实现迭代器协议的容器对象。它基于两个方法: 

• next 返回容器的写一个项目;
• __iter__ 返回迭代器本身。

迭代器可以通过使用一个iter内建函数和一个序列来创建，示例如下。 

Python代码  

1. >>> i = iter('abc')  
2. >>> i.next()  
3. 'a'  
4. >>> i.next()  
5. 'b'  
6. >>> i.next()  
7. 'c'  
8. >>> i.next()  
9. Traceback (most recent call last):  
10.   File "<stdin>", line 1, in <module>  
11. StopIteration  

引用

当序列遍历完时，将抛出一个StopIteration异常。这将使迭代器与循环兼容，因为它将捕获这个异常以停止循环。要创建定制的迭代器，可以编写一个具有next方法的类，只要该类能够提供返回迭代器实例的__iter__特殊方法。

Python代码  

1. class MyIterator(object):  
2.     def __init__(self, step):  
3.         self.step = step  
4.   
5.     def next(self):  
6.         if self.step == 0:  
7.             raise StopIteration  
8.         self.step -= 1  
9.         return self.step  
10.   
11.     def __iter__(self):  
12.         return self  
13.   
14. for el in MyIterator(4):  
15.     print el  

生成器 

引用

生成器提供了一种出色的方法，使得需要返回一系列元素的函数所需的代码更加简单、高效。基于yield指令，可以暂停一个函数并返回中间结果。该函数将保存执行环境并且可以在必要时恢复。 

Python代码  

1. #!/usr/bin/env python  
2. #-*-coding:utf-8-*-  
3.   
4. def fibonacci():  
5.     a, b = 0, 1  
6.     while  True:  
7.         yield b  
8.         a, b = b, a + b  
9.   
10. fib = fibonacci()  
11. print [fib.next() for i in range(10)]  
12. print map(lambda x,f = lambda x,f:f(x-1,f)+f(x-2,f) if x >1 else x:f(x,f),range(10))  

Python引入的与生成器相关的最后一个特性是提供了与next方法调用的代码进行交互的功能。yield将变成一个表达式，而一个值可以通过名为send的新方法来传递，如下所示。 

Python代码  

1. def psychologist():  
2.     print 'Please tell me your problems'  
3.     while True:  
4.         answer = (yield)  
5.         if answer is not None:  
6.             if answer.endswith('?'):  
7.                 print ("Don't ask yourself too much questions")  
8.             elif 'good' in answer:  
9.                 print "A that's good, go on"  
10.             elif 'bad' in answer:  
11.                 print "Don't be so negative"  
12.   
13. free = psychologist()  
14. free.next()  
15. free.send('I feel bad')  
16. free.send("?")  
17. free.send("ok then i should find what is good for me")  

Output: 
Please tell me your problems 
Don't be so negative 
Don't ask yourself too much questions 
A that's good, go on 

send的工作机制与next一样，但是yield将变成能够返回传入的值。因而，这个函数可以根据客户端代码来改变其行为。同时，还添加了throw和close两个函数，以完成该行为。它们将向生成器抛出一个错误： 
throw 允许客户端代码传入要抛出的任何类型的异常； 
close的工作方式是相同的，但是将会抛出一个特定的异常——GeneratorExit，在这种情况下，生成器函数必须再次抛出GeneratorExit或StopIteration异常。 

Python代码  

1. def my_generator():  
2.     try:  
3.         yield 'something'  
4.     except ValueError:  
5.         yield 'dealing with the exception'  
6.     finally:  
7.         print "ok let's clean"  
8.   
9. gen = my_generator()  
10. print gen.next()  
11. print gen.throw(ValueError('mean mean mean'))  
12. gen.close()  
13. print gen.next()  

finally部分在之前的版本是不允许使用的，它将捕获任何未被捕获的clise和throw调用，是完成清理工作的推荐方式。 
协同程序 

协同程序是可以挂起、回复，并且有多个进入点的函数。它们可以实现协同的多任务和管道机制。例如：每个协同程序将消费或生产的数据，然后暂停，直到其他数据被传递。 
在Python中，协同程序的替代者是线程，它可以实现代码块之前的交互。但是因为它们表现出一种抢先式的风格，所以必须注意资源锁，而协同程序不需要。这样的代码可能变得相当复杂，难以创建和调试。但是生成器几乎就是协同程序，添加send、throw和close其初始的意图就是为该语言提供一种类似协同程序的特性。 

使用multimask模块 

Python代码  

1. #!/usr/bin/env python  
2. # -*- coding:utf-8 -*-  
3. import multitask  
4.   
5. def coroutine_1():  
6.     for i in range(3):  
7.         print 'c1'  
8.         yield i   
9.   
10. def coroutine_2():  
11.     for i in range(3):  
12.         print 'c2'  
13.         yield i  
14.   
15. multitask.add(coroutine_1())  
16. multitask.add(coroutine_2())  
17. multitask.run()  

在协同程序之间的写作，最经典的例子是接受来自多个客户的查询，并将每个查询委托给对此作出相应的新线程的服务器应用程序。 

Python代码  

1. #!/usr/bin/env python  
2. # -*- coding:utf-8 -*-  
3.   
4. from __future__ import with_statement  
5. from contextlib import closing  
6. import socket  
7. import multitask  
8.   
9. def client_handler(sock):  
10.     while closing(sock):  
11.         while True:  
12.             data = (yield multitask.recv(sock, 1024))  
13.             if not data:  
14.                 break  
15.             yield multitask.send(sock, data)  
16.   
17. def echo_server(hostname, port):  
18.     addrinfo = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC,socket.SOCK_STREAM)  
19.     (family, socktype, proto, cannoname, sockaddr) = addrinfo[0]  
20.     with closing(socket.socket(family,socktype,proto)) as sock:  
21.         sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)  
22.         sock.bind(sockaddr)  
23.         sock.listen(5)  
24.         while True:  
25.             multitask.add(client_handler((yield multitask.accept(sock))[0]))  
26.   
27. if __name__ == "__main__":  
28.     import sys  
29.     hostname = None  
30.     port = 1111  
31.     if len(sys.argv) > 1:  
32.         hostname = sys.argv[1]  
33.     if len(sys.argv) > 2:  
34.         port = int(sys.argv[2])  
35.     multitask.add(echo_server(hostname,port))  
36.     try:  
37.         multitask.run()  
38.     except KeyboardInterrupt:  
39.         pass  

生成器表达式 

Python代码  

1. >>> iter = (x**2 for x in range(10) if x % 2 == 0)  
2. >>> for el in iter:  
3. ... print el  
4. …   
5. 0  
6. 4  
7. 16  
8. 36  
9. 64  

itertools模块 
islice:窗口迭代器 
tee:往返式的迭代器 
groupby：uniq迭代器 

Python代码  

1. #!/usr/bin/env python  
2. #-*-coding:utf-8-*-  
3.   
4. from itertools import group by  
5. def compress(data):  
6.     return ((len(list(group)),name) for name,group in groupby(data))  
7.   
8. def decompress(data):  
9.     return (car * size for size, car in data)  
10.   
11. print list(compress('get uuuuuuuuuuuuuuuup'))  
12. compressed = compress('get uuuuuuuuuuuuuuuup')  
13. print ''.join(decompress(compressed))