迭代器对象
实现了迭代器协议的对象叫做迭代器对象，迭代器对象可以使用 next 和 __next__ 方法进行迭代。
可以使用 iter 方法将字符串、列表等数据类型转换成迭代器对象：
str = "Hello World"
# 类型转换，将 str 转换为 iter 对象
iter_str = iter(str)
print(next(iter_str))
print(iter_str.__next__())
运行结果：
H
e
迭代完成后再使用 next 或 __next__ 方法进行迭代将会引发 StopIteration 异常：
str = "Hello"
# 类型转换，将 str 转换为 iter 对象
iter_str = iter(str)
print(next(iter_str))
print(next(iter_str))
print(next(iter_str))
print(next(iter_str))
print(next(iter_str))
print(next(iter_str))
运行结果：
H
Traceback (most recent call last):
File "C:\Users\Administrator\Desktop\py\py.py", line 10, in <module>
e
l
l
o
print(next(iter_str))
StopIteration
手动实现迭代器
只要实现了迭代器协议的对象就是迭代器对象，可以对该对象进行迭代，因此我们也可以手动实现迭代器。Python 中实现迭代器需要实现两个方法：
-
__iter__该方法返回迭代器对象本身 -
__next__规定每次迭代时返回的内容
下面手动实现一个迭代器：
class MyIter(object):
def __init__(self,count):
self.count = count
self.initVal = 0
# 实现 __iter__ 方法，返回迭代器对象本身
def __iter__(self):
return self
# 实现 __next__ 方法，规定迭代内容的返回值
def __next__(self):
if(self.initVal < self.count):
self.initVal += 1
return self.initVal - 1
else:
# 如果超出了范围，则触发 StopIteration 异常
raise StopIteration
# 创建一个迭代器对象
myiter = MyIter(5)
# 开始迭代
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(myiter.__next__())
print(myiter.__next__())
运行效果：
0
Traceback (most recent call last):
File "C:\Users\Administrator\Desktop\py\py.py", line 25, in <module>
1
2
3
4
print(myiter.__next__())
File "C:\Users\Administrator\Desktop\py\py.py", line 15, in __next__
raise StopIteration
StopIteration
手动实现的迭代器对象同样可以使用 next 和 __next__ 方法进行迭代，迭代完成后再进行迭代会引发 StopIteration 异常。
我们也可以对迭代器对象因此遍历：
...
# 创建一个迭代器对象
myiter = MyIter(5)
# 遍历迭代器对象
for i in myiter:
print(i)
运行结果如下：
0
1
2
3
4
上面就是迭代器的一些介绍，下面来介绍生成器。
生成器
生成器可以理解为生成一个迭代器的东西，生成器有以下两种实现方式：
- 使用列表推导式，将列表推导式中的
[]换成() - 在函数中使用
yield关键字
生成器生成出来的对象叫做生成器对象，由于该对象是可迭代的，因此其也是一个迭代器对象。推导式生成器和 yield 关键字可以看做是 __iter__ 和 __next__ 函数的语法糖。
推导式生成器
使用推导式生成器，只需将列表推导式中的 [] 换成 ()：
# 定义推导式生成器
gen = (x for x in range(5))
# 迭代
print(next(gen))
print(next(gen))
print(next(gen))
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
运行效果：
0
Traceback (most recent call last):
File "C:\Users\Administrator\Desktop\py\py.py", line 9, in <module>
1
2
3
4
print(gen.__next__())
StopIteration
yield 关键字
在函数中使用 yield 关键字后，该函数就是一个生成器函数，调用生成器函数返回一个生成器对象。
如果一个函数是生成器函数，这个函数的表现就和普通的表现不一样了，在调用该函数时不会直接执行函数内部的代码。
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
yield i
print("-----end-----")
g = gen(5)
运行效果：
[Finished in 0.1s]
可见，生成器函数内部的代码并没有直接执行。只有在对生成器对象使用 next 或 __next__ 进行迭代时，才会依次执行生成器函数中的代码，yield 关键字后表达式的值就是本次迭代时得到的值。
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
yield i
print("-----end-----")
g = gen(5)
for i in g:
print(i)
运行结果：
-----start-----
0
1
2
3
4
-----end-----
[Finished in 0.1s]
yield 表达式的值
程序运行到 yield 关键字，会返回 yield 后的表达式的值作为本次迭代的结果，然后暂停程序的执行，等待下一次迭代。那么，yield 表达式本身有没有值呢？我们可以进行一下验证：
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
tmpVal = yield i
print(tmpVal)
print("-----end-----")
g = gen(5)
for i in g:
print(i)
运行结果：
-----start-----
0
None
1
None
2
None
3
None
4
None
-----end-----
yield 表达式整体的值为 None，并不是 yield 关键字后的表达式的值。
send 方法
除了 next 或 __next__ 方法，还可以使用 send 方法进行迭代，send 方法需要接受一个参数，该参数将被作为 yield 表达式的值，如果不想指定其余参数，需要显示的传入 None。
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
tmpVal = yield i
print(tmpVal)
print("-----end-----")
g = gen(5)
print(g.send(None))
print(g.send("hello"))
print(g.send("world"))
运行结果：
-----start-----
0
hello
1
world
2
如果是第一次迭代，则使用 send 方法无法接受除 None 以外的值，否则会引发 TypeError 异常：
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
tmpVal = yield i
print(tmpVal)
print("-----end-----")
g = gen(5)
print(g.send("first"))
print(g.send("hello"))
print(g.send("world"))
运行结果：
Traceback (most recent call last):
File "C:\Users\Administrator\Desktop\py\py.py", line 11, in <module>
print(g.send("first"))
TypeError: can't send non-None value to a just-started generator
send 方法传递函数
除了传递字符串、数字等类型的值，我们还可以使用 send 方法想生成器函数中传入函数：
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
func = yield i
if func:
ret = func()
print(ret)
print("-----end-----")
g = gen(5)
g.__next__()
# 想生成器中传入一个函数
g.send(lambda:10086)
运行结果：
-----start-----
10086
使用 send 方法向生成器函数中传入函数的意义在于：我们可以和生成器实现交互，达到消息传递和流程控制的目的。
保存 send 传入的值
只要 yield 语句执行，其整体的表达式值就会发生变化，也就是说，除非我们每次都通过 send 方法传入相同的值，该值是不会被保存的：
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
tmpVal = yield i
print(tmpVal)
print("-----end-----")
g = gen(5)
g.__next__()
g.send("Hello")
g.__next__()
g.__next__()
g.__next__()
运行结果：
-----start-----
Hello
None
None
None
要解决这个问题，我们可以每次在 send 中传入相同的值，也可以通过某一特殊的条件将该条件下的 yield 值进行保存：
# 定义生成器函数
def gen(num):
print("-----start-----")
for i in range(num):
# 如果 i 为 0，则执行下面的 yield 语句
if not i:
tmpVal = yield i
# 如果 i 部位 0，执行下面的 yield 语句
else:
yield i
print(tmpVal)
print("-----end-----")
g = gen(5)
g.__next__()
g.send("Hello")
g.__next__()
g.__next__()
g.__next__()
运行结果：
-----start-----
Hello
Hello
Hello
Hello
协程
利用 yield 的特性，可以在某段时间内交出函数的控制权，我们可以利用这个特性进行并行任务的处理，这种方式叫做协程：
# 程序1
def task1():
while True:
print("-----程序1执行-----")
yield
# 程序2
def task2():
while True:
print("-----程序2执行-----")
yield
# 两个任务并行处理
t1 = task1()
t2 = task2()
for i in range(10):
t1.__next__()
t2.__next__()
运行结果：
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
-----程序1执行-----
-----程序2执行-----
总结
本文讲到了 Python 中的迭代器和生成器，下面是一些关键字：
- 迭代器和迭代器协议
- 手动实现迭代器
- 实现生成器的两种方式
-
yield关键字 -
yield表达式的值 - 使用
send方法向生成器内部值 - 使用
send方法向生成器内部传入函数 - 如何保存某次
send方法的传值 - 利用生成器实现协程
完。
