python迭代器和生成器-创新互联
python中的迭代器
可迭代对象
迭代是指重复反馈过程，每一次的迭代都会得到一个结果，又是下一次迭代的开始。
在python中，一个对象只要是实现了__iter__() 或__getitem__()方法，就被称为可迭代对象。
python中的可迭代对象有字符串、列表、元组、字典、文件；自定义的类若是实现了__iter__() 或__getitem__()方法，则也是可迭代对象~
遍历可迭代对象，这里仅以文件为例：
with open(file='/Users/luyi/tmp/abc', mode='r', encoding='utf-8') as f:
for line in f:
print(line, end='')迭代器
调用可迭代对象的__iter__() 方法，返回得到的就是一个迭代器，迭代器用于迭代可迭代对象中的每一个元素。
迭代器有两个方法：__iter__() 方法，__next__() 方法，调用迭代器的__iter__() 方法，返回的依旧是迭代器对象，即将自身返回。不断的调用__next__() 方法，则会逐个返回可迭代对象中的元素~
with open(file='/Users/luyi/tmp/abc', mode='r', encoding='utf-8') as f: # abc 文件中仅有3行内容
file_iter = f.__iter__() # 获取迭代器对象
print(file_iter.__next__(), end='') # 读取第一行内容
print(file_iter.__next__(), end='') # 读取第二行内容
print(file_iter.__next__(), end='') # 读取第三行内容
print(file_iter.__next__(), end='') # 对象中的元素已经全部迭代完成，所以这一行会抛出 StopIteration 异常
输出结果：
aaa
bbb
ccc
... # 省略部分报错信息
StopIteration如上所示，在获取可迭代对象的迭代器之后，不断调用迭代器的__next__() 方法，以遍历其中的所有元素，当全部遍历完成后，再次调用__next__() 方法，就会抛出 StopIteration 异常
遍历玩所有的元素，这样写会比较麻烦，因为需要不断的调用__next__() 方法，其实这里可以使用 for 循环替代，实现的方式在 实例1 中已经给出。
for...in... 循环的过程
for item in Iterable 循环 会调用 in 后面对象的 __iter__() 方法，得到迭代器，然后自动的，不断的 调用迭代器的__next__()方法，得到的返回值 赋值给 for 前面的item 变量，这样依次循环；直到调用__next__()方法时报错（StopIteration异常），for循环会自动捕获异常，然后循环结束~
Iterable, Iterator
Iterable, Iterator 用于判断一个对象是不是 可迭代对象或者 是不是迭代器~
使用语法如下：
from collections import Iterable, Iterator
isinstance(str1, Iterable)
isinstance(str1, Iterator)使用示例：
from collections import Iterable, Iterator
f = open(file='/Users/luyi/tmp/abc', mode='r', encoding='utf-8')
print(isinstance(f, Iterable)) # True
print(isinstance(f, Iterator)) # True
lst = [1, 2, 3]
print(isinstance(lst, Iterable)) # True
print(isinstance(lst, Iterator)) # False可见文件对象是可迭代对象，又是迭代器，而列表仅是可迭代对象~
迭代器的特性
总结一下，迭代器有以下 2 个特性：
1）提供了一种不依赖于索引的取值方式
2）惰性计算，节省内存
这里的节省内存是指 迭代器在迭代过程中，不会一次性把可迭代对象的所有元素都加载到内存中，仅仅是在迭代至某个元素时才加载该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点就使得迭代器适合用于遍历一些巨大的 或是 无限的集合。
迭代器的优缺点
1）取值不如按照索引取值来的方便（索引可以直接定位某一个值，迭代器不行，只能一个一个地取下去）
2）迭代器只能往后迭代，不能回退（执行__next__() 方法 只能向后，不能向前）
3）无法获取迭代器的长度
python中的生成器
生成器函数 和 生成器
生成器函数：函数体内包含有yield关键字，该函数执行的结果就是一个生成器（generator）。
>>> def foo():
... print('first----')
... yield 1
... print('second----')
... yield 2
... print('third----')
... yield 3
... print('fouth----')如上示例中 foo函数就是一个生成器函数，而执行foo()函数后，返回的就是一个生成器对象。生成器具有 __next__() 方法 和 __iter__()，所以生成器就是一种迭代器~
调用该生成器函数后，返回generator对象，然后通过调用 __next__() 方法不断获得下一个返回值：
>>> g = foo() # 返回一个生成器
>>> g
>>> g.__next__() # 这里也可以使用 next(g) 来替代
first----
1
>>> g.__next__()
second----
2
>>> g.__next__()
third----
3
>>> g.__next__()
fouth----
Traceback (most recent call last):
File "", line 1, in
StopIteration 在调用 生成器 的 __next__() 方法时，会执行对应生成器函数中的内容，执行过程中，每次遇到 yield 就会返回 yield 后面的变量（或者表达式），随即中断；再次调用生成器 的 __next__() 方法，会从上一次的中断处继续往后执行；而最后一次执行__next__()方法，后面已经没有 yield，在打印了 'fouth----' 之后就会抛出 StopIteration 异常~
一般很少使用 __next__() 方法来迭代生成器，而是直接使用for循环来迭代，且for循环会自动捕获 StopIteration 异常：
g = foo()
for i in g:
print(i)
输出结果：
first----
1
second----
2
third----
3
fouth----
生成器函数一般也会同 for 循环配合使用，例如使用通配符匹配指定目录下的文件并打印：
def files(dest_dir = '/Users/luyi/tmp/', end = '*.log'):
for i in glob.glob(os.path.join(dest_dir, end)):
yield i
# files() 得到一个生成器
print(files()) #
for i in files(): # 遍历这个生成器
print i
输出结果：
/Users/luyi/tmp/2.log
/Users/luyi/tmp/3.log
/Users/luyi/tmp/1.log yield功能总结：
1）与return类似，都可以返回值，但不一样的地方在于 yield 返回多次值，而 return 只能返回一次
2）为函数封装好了__iter__() 和 __next__() 方法，把函数的执行结果做成了迭代器
3）遵循迭代器的取值方式（obj.__next__()），这样的操作会触发函数的执行，函数暂停与再继续的状态都是由 yield 保存（暂停于yield处，下一次的 __next__() 方法执行后，会从 yield 处继续往下执行）
yield的表达式形式
>>> def foo():
... print('start...')
... while True:
... x = yield
... print(x)
...
>>> g = foo() # 第一次执行生成器，必须是 next 或者 send(None)，类似于初始换的操作，即让程序执行至第一个 yield，并中断~
>>> next(g)
start...
>>> g.send(2)
2
>>> g.send(3)
3
>>> next(g) # 没有传值的情况
None这里生成器的 send() 方法会先将值传递给 yield，然后由 yield 赋值给 x，赋值完成之后，继续往下执行，直到再一次遇到yield。所以 send 的作用和 next 方法相同，还多了一个赋值功能。
send 的 2个作用：
1）传值给 yield，然后由 yield 传递给变量（若没有传值给 yield，则 yield 会将 None 赋值给变量）
2）与next相同的功能
上述示例中使用 send 之前，必须对生成器来一个类似于初始化的操作：执行next 或者 send(None)。为了简化这个步骤，这里可以使用装饰器：
def init(func): # 这个装饰器可以重复使用（装饰其它生成器）
def wrapper(*args, **kwargs):
g = func(*args, **kwargs)
next(g)
return g
return wrapper
@init
def foo():
print('start...')
while True:
x = yield
print(x)
g = foo()
g.send('abc')yield表达式一共有4种：
1）yield exp，仅有返回值，exp可以是函数，表达式等
2）s = yield exp，有返回值，且可以传入一个值存入 s 中
3）s = yield，可传入一个值，没有返回值（返回为None）
4）yield，不接受输入，也没有返回值（返回为None）
生成器的应用
python中的生成器（generator）通常用来实现协程，即在执行一个函数的过程中，中断当前函数，转而去执行别的函数，执行完成之后，返回来继续当前函数的执行，整个过程在一个线程中完成；也可以换个角度来进行理解，即当前函数的循环执行会不断产生数据，将每一次产生的数据交由另一个函数做进一步的处理，处理完成之后返回，继续执行当前函数~
下面通过一个简单的生产者-消费者模型来说明：
def init(func):
def wrapper(*args, **kwargs):
g = func(*args, **kwargs)
next(g)
return g
return wrapper
@init
def consumer():
res = ''
while True:
p = yield res
if not p:
continue
print('Consuming %s...' % p)
res = 'OK'
def produce(c):
for i in range(1,5):
print('producing %s...' % i)
r = c.send(i)
print('return status: %s' % r)
c.close()
c = consumer()
produce(c)
输出结果：
producing 1...
Consuming 1...
return status: OK
producing 2...
Consuming 2...
return status: OK
producing 3...
Consuming 3...
return status: OK
producing 4...
Consuming 4...
return status: OK执行流程说明：
1.c = consumer() 拿到的已经是初始化后的生成器（即生成器已经执行了一次next(c)）；
2.调用 produce()，生产数据之后，通过send(i)，将数据发送给 consumer，并且切换到consumer执行；
3.consumer 通过 yield 获取数据，然后进行消费，最后通过 yield 把处理结果返回给produce；
4.produce 获取 consumer 的处理结果之后，继续生产下一次的数据~
.................^_^
另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
文章标题：python迭代器和生成器-创新互联
分享链接：http://hbruida.cn/article/cosegg.html
