列表生成式：
需求：列表[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对象。