一、列表生成式
如果有这样一个列表[1,2,3,4,5,6,7,8,9,10] ,现在需要将列表里的每个元素乘以2，应该怎么做呢？
方法一：
# -*-coding:utf-8-*-
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for index,i in enumerate(a):
a[index] *= 2
print(a) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
方法二：
#-*- coding:utf-8 -*-
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(map(lambda x:x*2,a))) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
似乎已经可以实现了，但是还有没有其他方法呢？
答案当然是有的，而且还很简洁，功能更强，不信，接着看：
#！/usr/bin/env python3
#-*- coding:utf-8 -*-
#列表生成式
a = [1,2,3,4,5,6,7,8]
a = [i if i< 4 else i*i for i in a] # 前三个数不变，后面的数都平方
print(a) #输出：[1, 2, 3, 16, 25, 36, 49, 64]
注意：
[i if i< 4 else i*i for i in a]可视为两部分，i if i<4 else i*i 为三元运算,视为一个整体，
看成一个’变量‘，for i in a 和这个变量组成列表生成式，i每在列表a中被赋值一次，‘变量‘就运行一次。
变量得出的结果就是列表中的元素。
这种写法就是列表生成式。
二、生成器
1、生成器的由来：
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，
不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？
这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
2、创建生成器的简单方法
L = [x*2 for x in range(10)]
print(l) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 列表
g = (x * 2 for x in range(10))
print(g) # <generator object <genexpr> at 0x1022ef630> 生成器
#创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。
那我们怎样取出我们想要的值呢？
方法一：通过next()函数获得generator的下一个返回值。
g = (x * 2 for x in range(4))
print(g) # <generator object <genexpr> at 0x1022ef630> 生成器
print(next(g)) # 0
print(next(g)) # 2
print(next(g)) # 4
print(next(g)) # 6
print(next(g)) # StopIteration 生成结束会报错
注意：generator保存的是算法，每次调用next(g)就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
方法二（推荐）：使用for循环，因为generator也是可迭代对象，至于可迭代对象待会儿会说，现在你知道生成器可使用for循环就行了。
a = (i for i in range(3))
for i in a: # for循环输出生成器完成后不会报错，但while和手动生成完后会报错
print(i)
‘‘‘
输出：
0
1
2
‘‘‘
3、我们可以推测一下生成器有哪些特点：
主要是这样三个：取一次生成一个，只能向前，生成完成后报错误提示（StopIteration）。
4、生成器的实际运用
先看一个斐波那契数列是怎样用函数生成的。
def fib(max):
n,a,b = 0,0,1 # 设置初始值
while n < max: # 执行次数
print(b) # 打印每次执行后的值
a,b = b,a+b # 交换赋值
n += 1
return ‘end‘ # 退出
fib(6) # 函数调用
那这和生成器有什么关系呢？其实原理是一样的。fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。
我们来稍微修改一下这个函数：
# 斐波拉契数列 和 yield
def fib(max):
n,a,b = 0,0,1
while n < max:
#print(‘before yield!‘)
yield b # 把函数的执行过程冻结在这一步，并且把b的值，返回给外面的next()
#print(b)
a,b = b,a+b
n += 1
return ‘Done‘
f = fib(6) # 内部代码不执行，只是将函数转为生成器
#循环输出
# for i in f:
# print(i)
print(next(f))# 输出：1 # next()唤醒冻结的执行过程，继续执行，直到碰到下一个yield
print(next(f),type(f)) # 输出：1 <class ‘generator‘>
print(next(f)) # 输出：2
print(f.__next__()) # 输出：3 #f.__next__()等同于next（f）
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。
函数和生成器执行流程的区别：函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，
在每次调用next()的时候执行，遇到yield语句返回，再次被next()调用时从上次返回的yield语句处继续执行。
def func(n):
count = 0
while count < n:
print(‘count‘,count)
sign = yield count # yield 把函数的执行过程冻结在这一步，并且把count的值，返回给外面的next()
print(‘--sign--‘,sign)
count += 1
return 666
f = func(3)
print( next(f)) # 0
print( next(f)) # 1
print(f.send(‘pause‘)) # 发送消息,唤醒并继续执行
print( next(f)) # 2 print( next(f)) # 报错：StopIteration: 666
‘‘‘
函数中有了yield之后
1、函数名加（）就变成了一个生成器
2、return在生成器里，代表生成器的中止，直接报错
next 唤醒并继续执行，只能默认发送消息None
函数中有了send之后,send(‘pause‘)
1、唤醒并继续执行
2、发送一个消息到生成器内部
‘‘‘
我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。
同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
for n in fib(6):
print(n)
‘‘‘
1
1
2
3
5
8
‘‘‘
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
g = fib(6)
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
Generator return value: done
‘‘‘
还可通过yield实现在单线程的情况下实现并发运算的效果。
#_*_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("jack")
三、迭代器
1、定义：可以被next()函数调用并不断返回下一个值的对象称为迭代器，Iterator。
2、可直接作用于for循环的数据类型有以下几种：
一类是：集合数据类型，如list,tuple,dict,set,str等
一类是：generator,包括生成器和带yield的生成器函数
这样可直接作用于for 循环的对象统称为可迭代对象：Iterable
可以使用 isinstance()判断一个对象是否是Iterable对象
3、可以使用 isinstance()判断一个对象是否是Iterable对象
from collections import Iterable
print(isinstance([],Iterable)) # True
print(isinstance(‘abc‘,Iterable)) # True
4、可以使用 isinstance()判断一个对象是否是Iterator(迭代器)
from collections import Iterator
print(isinstance((x for x in range(5)),Iterator)) # True
print(isinstance([],Iterator)) # False
5、可迭代对象和迭代器的区别：
list、dict、str等虽然都是Itrable，但并不是迭代器，可以通过 iter()函数把list,dict,str等变成迭代器。
from collections import Iterator
print(isinstance(iter([]),Iterator)) # True
print(isinstance(iter(‘abc‘),Iterator)) # True
6、迭代器和生成器的区别：
迭代器包括生成器，生成器都是迭代器（Iterator）,但迭代器不一定是生成器。
7、小结：
凡是可作用于for循环的对象都是可迭代对象（Iterable）.
凡是可作用于next（）函数的对象都是Iterator类型，它们表示一个惰性计算的序列。
集合数据类型如list,dict,str等都是可迭代对象但不是迭代器，但可以通过iter()函数获得一个迭代器对象。
python3中 for循环本质上就是通过不断调用next()函数实现的。