迭代器对象
实现了迭代器协议的对象叫做迭代器对象,迭代器对象可以使用 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
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
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
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
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
方法的传值 - 利用生成器实现协程
完。