python--day4--迭代器、生成器

列表生成式：

需求：列表[1,2,3,4,5,6,7,8,9]每个值加1，实现的方法：

a = [0,1,2,3,4,5,6,7,8,9]
b = []
for i in a:b.append(i+1)
a = b
print(a)

第二种方法：

a = [1,2,3,4,5,6,7,8,9]
a = map(lambda x:x+1,a)
for i in a :print(i)

第三种方式：（列表生成式）

a = [i+1 for i in range(10)]
print(a)

生成器：

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

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

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

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

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

创建的L是列表，而g是一个生成器。

打印元素：

print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())

输出：
0
Traceback (most recent call last):
1
  File "D:/workspace/day4/generator_mod.py", line 12, in <module>
4
    print(g.__next__())
9
StopIteration
16
25
36
49
64
81

当索取的值超过列表长度时，报错:StopIteration

使用for循环来调用生成器：

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

for i in g:
    print(i)

0
1
4
9
16
25
36
49
64
81

一般创建generator后，基本不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration错误。

使用函数来实现较为复杂的斐波那契数列：

def fib(max):
    n,a,b=0,0,1
    while n < max:
        print(b)
        a,b = b,a+b  #注意赋值语句，
        n = n+1
    return 'done'

#注意赋值语句a,b=b,a+b相当于：
#t=(b,a+b)  #t是一个元组
#a=t[0]
#b=t[1]

#执行：
fib(10)
1
1
2
3
5
8
13
21
34
55

把上面的函数变成generator，只需要把print(b)改成yield b就可以了，如下：

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

    while n < max:
        yield b
        a,b = b,a+b
        n += 1
    return 'done'

f = fib(6)
print(f)

#输出：
<generator object fib at 0x00000239D28A6888>

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

比较难理解的是generator执行流程和函数不太一样，函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()

的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

data = fib(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__())

#输出
<generator object fib at 0x000001EB0E016990>
1
1
打个标记
2
3
5
8
13

使用for循环来迭代：

for n in fib(6):
    print(n)

#输出
1
1
2
3
5
8

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

g = fib(10)
while True:
    try:
        x = next(g)
        print('g',x)
    except StopIteration as e:
        print('Generator return value:',e.value)
        break

#输出：
g 1
g 1
g 2
g 3
g 5
g 8
g 13
g 21
g 34
g 55
Generator return value: done

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

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("%s开始准备做包子啦!"%name)
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("Tim")

迭代器：

一般来说，可以使用for循环来操作的对象成为可迭代对象，如列表，元组，集合，字典，字符串，generator等。

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

from collections import Iterable
>>>isinstance([],Iterable)
True
>>>isinstance(x for x in range(10),Iterable)
True

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

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

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

from collections import Iterator
>>>isinstance((x for x in range(10)),Iterator)
True
isinstance([],Iterator)
False

生成器都是Iterator对象，但list,dict,str虽然是Iterable,但不是Iterator.

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

>>>isinstance(iter[],Iterator)
True
>>>isinstance(iter('abc'),Iterator)
True

列表，元组，字典等对象的长度是可知的，而Iterator对象的长度是未知的，可以通过for,next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的。

小结：

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

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

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