迭代器、生成器

迭代器对象

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

完。