迭代器与生成器精讲-优快云博客

迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
不能随机访问集合中的某个值，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存

生成一个迭代器：

>>> a = iter([1,2,3,4,5])
>>> a
<list_iterator object at 0x101402630>
>>> a.__next__()
>>> a.__next__()

生成器generator

定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器

 
       def  
       cash_out(amount): 
      
 
            
       while  
       amount > 
       0 
       : 
      
 
                
       amount  
       - 
       =  
       1 
      
 
                
       yield  
       1 
       <br>         
       print 
       ( 
       "擦，又来取钱了。。。败家子！" 
       ) 
      

          
      

          
      

          
      
 
       ATM  
       =  
       cash_out( 
       5 
       ) 
      

          
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      
 
       print 
       ( 
       "花掉花掉!" 
       ) 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      
 
       print 
       ( 
       "花掉花掉!" 
       ) 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__())  
       #到这时钱就取没了,再取就报错了 
      
 
       print 
       ( 
       "取到钱 %s 万"  
       %  
       ATM.__next__()) 
      

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]

>>> L

[ 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 , 81 ]

>>> g = (x * x for x in range ( 10 ))

>>> g

<generator object <genexpr> at 0x1022ef630 >

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(max):

n, a, b = 0 , 0 , 1

while n < max :

print (b)

a, b = b, a + b

n = n + 1

return 'done'

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):
    n,a,b = 0,0,1

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done' 
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

#_*_coding:utf-8_*_

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

转载于:https://www.cnblogs.com/ws0751/p/6911407.html