Python 迭代器和生成器_python引入的与生成器相关的最后一个特性-CSDN博客

本文详细介绍了 Python 中的迭代器和生成器概念，包括如何创建和使用迭代器，生成器的基础语法及高级应用，如 send、throw 和 close 方法。此外，还探讨了生成器与协同程序的关系，并通过代码示例展示了这些概念的实际应用。

摘要由CSDN通过智能技术生成

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

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

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

    Python代码   
    
  
 >>> i = iter('abc')  
 >>> i.next()  
 'a'  
 >>> i.next()  
 'b'  
 >>> i.next()  
 'c'  
 >>> i.next()  
 Traceback (most recent call last):  
   File "<stdin>", line 1, in <module>  
 StopIteration  

引用

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

    Python代码   
    
  
 class MyIterator(object):  
     def __init__(self, step):  
         self.step = step  
   
     def next(self):  
         if self.step == 0:  
             raise StopIteration  
         self.step -= 1  
         return self.step  
   
     def __iter__(self):  
         return self  
   
 for el in MyIterator(4):  
     print el  

生成器

引用

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

    Python代码   
    
  
 #!/usr/bin/env python  
 #-*-coding:utf-8-*-  
   
 def fibonacci():  
     a, b = 0, 1  
     while  True:  
         yield b  
         a, b = b, a + b  
   
 fib = fibonacci()  
 print [fib.next() for i in range(10)]  
 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代码   
    
  
 def psychologist():  
     print 'Please tell me your problems'  
     while True:  
         answer = (yield)  
         if answer is not None:  
             if answer.endswith('?'):  
                 print ("Don't ask yourself too much questions")  
             elif 'good' in answer:  
                 print "A that's good, go on"  
             elif 'bad' in answer:  
                 print "Don't be so negative"  
   
 free = psychologist()  
 free.next()  
 free.send('I feel bad')  
 free.send("?")  
 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代码   
    
  
 def my_generator():  
     try:  
         yield 'something'  
     except ValueError:  
         yield 'dealing with the exception'  
     finally:  
         print "ok let's clean"  
   
 gen = my_generator()  
 print gen.next()  
 print gen.throw(ValueError('mean mean mean'))  
 gen.close()  
 print gen.next()  

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

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

使用multimask模块

    Python代码   
    
  
 #!/usr/bin/env python  
 # -*- coding:utf-8 -*-  
 import multitask  
   
 def coroutine_1():  
     for i in range(3):  
         print 'c1'  
         yield i   
   
 def coroutine_2():  
     for i in range(3):  
         print 'c2'  
         yield i  
   
 multitask.add(coroutine_1())  
 multitask.add(coroutine_2())  
 multitask.run()  

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

    Python代码   
    
  
 #!/usr/bin/env python  
 # -*- coding:utf-8 -*-  
   
 from __future__ import with_statement  
 from contextlib import closing  
 import socket  
 import multitask  
   
 def client_handler(sock):  
     while closing(sock):  
         while True:  
             data = (yield multitask.recv(sock, 1024))  
             if not data:  
                 break  
             yield multitask.send(sock, data)  
   
 def echo_server(hostname, port):  
     addrinfo = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC,socket.SOCK_STREAM)  
     (family, socktype, proto, cannoname, sockaddr) = addrinfo[0]  
     with closing(socket.socket(family,socktype,proto)) as sock:  
         sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)  
         sock.bind(sockaddr)  
         sock.listen(5)  
         while True:  
             multitask.add(client_handler((yield multitask.accept(sock))[0]))  
   
 if __name__ == "__main__":  
     import sys  
     hostname = None  
     port = 1111  
     if len(sys.argv) > 1:  
         hostname = sys.argv[1]  
     if len(sys.argv) > 2:  
         port = int(sys.argv[2])  
     multitask.add(echo_server(hostname,port))  
     try:  
         multitask.run()  
     except KeyboardInterrupt:  
         pass  

生成器表达式

    Python代码   
    
  
 >>> iter = (x**2 for x in range(10) if x % 2 == 0)  
 >>> for el in iter:  
 ... print el  
 …   
 0  
 4  
 16  
 36  
 64  

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

    Python代码   
    
  
 #!/usr/bin/env python  
 #-*-coding:utf-8-*-  
   
 from itertools import group by  
 def compress(data):  
     return ((len(list(group)),name) for name,group in groupby(data))  
   
 def decompress(data):  
     return (car * size for size, car in data)  
   
 print list(compress('get uuuuuuuuuuuuuuuup'))  
 compressed = compress('get uuuuuuuuuuuuuuuup')  
 print ''.join(decompress(compressed))  