一、迭代器的基本概念
-
什么是迭代器
迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续的，==单纯的重复并不是迭代==。
-
为何要有迭代器
迭代器是用来迭代取值的工具，而涉及到把多个值循环取出来的类型有：列表、字符串、元组、字典、集合、打开的文件
l = ['Python', 'JavaScript', 'Golang'] i = 0 while i < len(l): print(l[i]) i += 1上述迭代取值的方式只适用于有索引的数据类型：列表、字符串、元组。
为了解决基于索引迭代取值的局限性，python必须提供一种能够不依赖于索引的取值方式，这就是迭代器。
二、迭代器的实现
可迭代对象(可以转换成迭代器的对象)
但凡内置有_ _iter_ _方法的都称之为可迭代对象
s1 = ''
s1.__iter__()
l = []
l.__iter__()
t = (1,)
t.__iter__()
d = {'a': 1}
d.__iter__()
set1 = {1, 2, 3}
set1.__iter__()
with open('a.txt', mode='w') as f:
f.__iter__()
pass
调用可迭代对象下的_ _iter_ _方法会将其转换成迭代器对象
d = {'a': 1, 'b': 2, 'c': 3}
d_iterator = d.__iter__()
print(d_iterator) # <dict_keyiterator object at 0x0000024BE69DCF40>
print(d_iterator.__next__()) # a
print(d_iterator.__next__()) # b
print(d_iterator.__next__()) # c
# print(d_iterator.__next__()) # 抛出异常StopIteration 无值可取
d = {'a': 1, 'b': 2, 'c': 3}
d_iterator = d.__iter__()
while True:
try:
print(d_iterator.__next__())
except StopIteration:
break
print('====>>>>>>')
# 在一个迭代器取值取干净的情况下，再对其取值是取不到的
while True:
try:
print(d_iterator.__next__())
except StopIteration:
break
# 当怀疑一段代码会有逻辑异常时，防止程序崩溃可以加try...except，如果try下面代码异常且符合except后面的异常名，则执行except下面的代码。
# 运行结果：
# a
# b
# c
# ====>>>>>>
在一个迭代器取值取干净的情况下，再对其取值是取不到的，想要再取就得再生成一次迭代器对象。
d = {'a': 1, 'b': 2, 'c': 3}
d_iterator = d.__iter__()
while True:
try:
print(d_iterator.__next__())
except StopIteration:
break
print('<hr>')
d_iterator = d.__iter__()
while True:
try:
print(d_iterator.__next__())
except StopIteration:
break
# 运行结果：
# a
# b
# c
# <hr>
# a
# b
# c
有索引的类型也可以使用这种方法取值：
l = [1, 2, 3, 4, 5]
l_iterator = l.__iter__()
while True:
try:
print(l_iterator.__next__())
except StopIteration:
break
# 运行结果：
# 1
# 2
# 3
# 4
# 5
可迭代对象与迭代器对象详解
-
==可迭代对象（"可以转换成迭代器的对象"）：内置有_ _iter_ _方法的对象==
可迭代对象._ _iter_ _()：得到迭代器对象
可迭代对象有字符串、列表、元组、字典、集合、文件对象
-
==迭代器对象：内置有_ _next_ _方法并且内置有_ _iter_ _方法的对象==
迭代器对象._ _next_ _()：得到迭代器的下一个值
迭代器对象._ _iter_ _()：得到迭代器的本身，说白了调了跟没调一个样
dic = {'a': 1, 'b': 2, 'c': 3} dic_iterator = dic.__iter__() # 得到了一个迭代器 print(dic_iterator is dic_iterator.__iter__().__iter__().__iter__()) # True迭代器对象有文件对象
for循环的工作原理：for循环可以称之为叫迭代器循环
d = {'a': 1, 'b': 2, 'c': 3}
for k in d:
print(k)
- d._ _iter_ _()得到一个迭代器对象
- 迭代器对象._ _next_ _()拿到一个返回值，然后将该返回值赋值给k
- 循环往复步骤2，直到抛出StopIteration异常，for循环会捕捉异常然后结束循环
所以，迭代器对象._ _iter_ _()得到迭代器的本身并不是一个鸡肋的功能，而是为了让for循环对可迭代对象和迭代器对象进行无差别处理，让其工作原理统一起来。
迭代器优缺点总结
优点：
- 为有索引的类型和无索引的类型提供了一种统一的迭代取值方式。
- 惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流。而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。
缺点：
- 除非取尽，否则无法获取迭代器的长度
- 只能取下一个值，不能回到开始，更像是“一次性的”，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next，直到取尽。若是要再次迭代同个对象，只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。
三、生成器（自定义迭代器）
如何得到自定义的迭代器：yield关键字
在函数内一旦存在yield关键字，那么调用该函数就不会再执行函数体代码，而是会返回一个生成器对象，生成器即自定义的迭代器。
def func():
print('第一次')
yield 1
print('第二次')
yield 2
print('第三次')
yield 3
print('第四次')
g = func()
print(g) # <generator object func at 0x00000207C033B970>
# 生成器就是迭代器
g.__iter__()
# g.__next__()会触发函数体代码的运行，然后遇到yield停下来，将yield后的值当做本次调用的结果返回
res1 = g.__next__() # 第一次
print(res1) # 1
res2 = g.__next__() # 第二次
print(res2) # 2
res3 = g.__next__() # 第三次
print(res3) # 3
res4 = g.__next__() # 第四次 # 然后遇不到yeid了，报异常
写法形式上的补充：
len('aaa') 等同于 'aaa'.__len__()
next(g) 等同于 g.__next__()
iter(可迭代对象) 等同于 可迭代对象.__iter__()
生成器应用案例：写一个range函数，包括起始值、结束值、步长
def my_range(start, stop, step=1):
while start < stop:
yield start
start += step
g = my_range(1, 9, 2)
print(next(g)) # 1
print(next(g)) # 3
print(next(g)) # 5
print(next(g)) # 7
def my_range(start, stop, step=1):
while start < stop:
yield start
start += step
for i in my_range(1, 10, 2):
print(i) # 1 3 5 7 9
总结yield：有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态，挂起函数，用来返回多次值。
生成器的高级玩法之yield挂起函数：yield的表达式形式
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater()
res0 = next(g) # Ready to eat # 触发代码的运行，遇到yield停下，返回yield后面的值，没有则为None。
print(res0) # None
res1 = next(g) # get the food: None, and start to eat
print(res1) # None
在函数内可以采用表达式形式的yield，拿到函数的生成器对象后进而持续为函数体send值(==只能传一个值，需要传多个值可以使用列表装起来==)，如下：
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater() # 得到生成器对象
print(g) # <generator object eater at 0x0000018E5F33B970>
next(g) # Ready to eat # 触发代码的运行，遇到yield停下
next(g) # get the food: None, and start to eat
next(g) # get the food: None, and start to eat
g.send('香蕉西瓜皮') # get the food: 香蕉西瓜皮, and start to eat
g.send('麻辣小龙虾') # get the food: 麻辣小龙虾, and start to eat
==针对表达式形式的yield，生成器对象必须事先被初始化一次（g.send(None)或next(g)）==，让函数挂起在food=yield的位置，等待调用g.send()方法为函数体传值，g.send(None)等同于next(g)。
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater()
# 不初始化直接g.send(内容)会报错
g.send('香蕉西瓜皮')
g.send('麻辣小龙虾')
# TypeError: can't send non-None value to a just-started generator
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater()
g.send(None)
g.send('香蕉西瓜皮') # get the food: 香蕉西瓜皮, and start to eat
g.send('麻辣小龙虾') # get the food: 麻辣小龙虾, and start to eat
==要注意：send给的值并不是返回值，而是在yield所在的表达式中，yield的值为本次send的内容。真正的返回值从始至终都是yield后面的值，没有则默认为None：==
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater()
next(g) # Ready to eat
res = g.send('哈哈气泡水') # get the food: 哈哈气泡水, and start to eat
print(res) # None
def eater():
floodlit = []
print('Ready to eat')
while True:
food = yield floodlit
print('get the food: %s, and start to eat' % food)
floodlit.append(food)
g = eater()
next(g) # Ready to eat # 初始化
res1 = g.send('哈哈气泡水')
print(res1) # ['哈哈气泡水']
res2 = g.send('蜜雪冰城')
print(res2) # ['哈哈气泡水', '蜜雪冰城']
res3 = g.send('益禾堂')
print(res3) # ['哈哈气泡水', '蜜雪冰城', '益禾堂']
# 先执行 food=yield，然后执行下面的代码块。
# 直到碰到下一个yield的时候，代表此次执行结束，此刻yield后面的值是啥就把啥当做此次执行的返回值返回，而不是从执行一开始就把返回值固定。
# 比如g.send('哈哈气泡水')，先执行food='哈哈气泡水'，然后执行下面的两行代码。
# 第二次循环开始后，在第一行碰到了yield，此刻foodList=['哈哈气泡水']，于是直接将它当做g.send('哈哈气泡水')的返回值。
def eater():
print('start...')
x = yield 111
print('x是', x)
x = yield 222
print('x是', x)
g = eater()
res = next(g) # start...
print(res) # 111
res1 = g.send('一') # x是 一
print(res1) # 222
g.close()：关掉生成器，不能继续send传值，也不能正常next()了（因为next(g)等同于g.send(None)）。
def eater():
print('Ready to eat')
while True:
food = yield
print('get the food: %s, and start to eat' % food)
g = eater()
next(g) # Ready to eat
g.send('哈哈气泡水') # get the food: 哈哈气泡水, and start to eat
g.close()
g.send('aaa') # 报错
next(g) # 报错