迭代器、生成器

迭代器对象

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

完。

你可能感兴趣的:(迭代器、生成器)