列表生成式，生成器和迭代器

1.列表生成式

语法：[条件表达式  for i in iterable]

a=list(range(10))
b=[i+1 for i in a]   #这种形式就是列表生成式
print(b)

用列表生成式可以简化代码，等价于下面的几种方法：

#方法一
a=list(range(10))
b=[]
for i in a:
    b.append(i+1)

print(b)

#方法二
a=list(range(10))
for index,i in enumerate(a):
    a[index]+=1
print(a)

#方法三
a=list(range(10))
a=map(lambda a:a+1,a)  #返回的是一个内存地址，想要调用需要用for循环
for i in a:
    print(i)

2.生成器

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

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

2.1 创建generator：

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

l=[x*x for x in range(10)]
print(l)
g=(x*x for x in range(10))
print(g)

返回：

 生成器g返回的是函数的内存地址，想要打印出g里面的元素，可以使用

for i in g:
    print(i)　　

返回

 注意：

　　1.创建l 和g的区别仅在于最外层的[]和()，l 是一个list，而g是一个generator。

　　2.列表可以进行切片和索引，生成器g没有办法进行切片和索引。生成器只能在调用的时候才会返回相应的数据。

　　3.打印生成器g的数据的方式，只有一个一个的取：一种是用for循环逐次打印，一种是用next()函数获得generator的下一个返回值。

　　生成器只记住当前的位置，既不知道之前的，也不知道之后的，只能一个一个地往后下一个取。

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象。

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

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

第二种方法：用函数做生成器，yield

 实例：斐波拉契Fibonaccl数列：除第一个和第二个数外，任意一个数都可由前两个数相加得到：

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

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

def fibo(max):
    n,a,b=0,0,1
    while n<max:
        print(b)
        a,b=b,a+b  #等价于t=(a,a+b)，a=t[0],b=t[1] 但不必显式写出临时变量t就可以赋值。
        n+=1
    return 'done'

fibo(10)

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

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

def fibo(max):
    n,a,b=0,0,1
    while n<max:
        yield b
        a,b=b,a+b  #等价于t=(a,a+b)，a=t[0],b=t[1] 但不必显式写出临时变量t就可以赋值。
        n+=1
    return 'done'


for i in fibo(10):
    print(i)

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

 f = fib(6)
 f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。　　

def fibo(max):
    n,a,b=0,0,1
    while n<max:
        yield b
        a,b=b,a+b  #等价于t=(a,a+b)，a=t[0],b=t[1] 但不必显式写出临时变量t就可以赋值。
        n+=1
    return 'done'  #异常时打印的消息


data = fibo(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

返回：

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代。但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

def fibo(max):
    n,a,b=0,0,1
    while n<max:
        yield b   #想要返回什么，就在哪里加yield。
        a,b=b,a+b  #等价于t=(a,a+b)，a=t[0],b=t[1] 但不必显式写出临时变量t就可以赋值。
        n+=1
    return 'done'

f=fibo(10)
while True:
    try:
        x=next(f)   #debugger中，x=next(f)就是调用f，到yield b中止，下次调用函数，则继续运行a,b=a,a+b;n+=1
        print('fibo:',x)
    except StopIteration as e:
        print('Generator return value:',e.value)
        break

2.2 通过yield在单线程情况下实现并发运算的效果

#典型的生产者-消费者模型
import time
def consumer(name):
    print('%s 准备吃包子啦！'%name)
    while True:
        baozi=yield   #通过下面的send给yield传值，baozi=c.send('object')

        print('包子[%s]来了，被[%s]吃了！'%(baozi,name))


def producer(name):
    c0=consumer(name)
    c1=consumer('Zzz')
    c0.__next__()  #只有调用__next__()才能从开始调用consumer()函数
    c1.__next__()
    print('厨师开始做包子')
    for i in range(10):
        time.sleep(1)
        print('做了2个包子！')
        c0.send(i)
        c1.send(i)


producer('david')

返回：

3.迭代器

 我们已经知道，可以直接作用于for循环的数据类型有以下几种：

　　一类是集合数据类型，如list、tuple、dict、set、str等；

　　一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

 

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

 

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

1 2	for x in [1, 2, 3, 4, 5]:     pass

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break