Python 中的迭代器（iter、next）与生成器（yield）解析

Python 中的迭代器（Iterator）是一个可以记住遍历位置的对象，用于迭代列表、元组、字典、集合和字符串等可迭代（Iterable）对象，迭代器从集合的第一个元素开始访问，直到所有的元素被访问完结束，并且只能往前不会后退。使用 collections.abc 库中的 Iterable 和 Iterator 可以判断对象是否可迭代和是否为迭代器。

>>> from collections.abc import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance(100, Iterable)
False
1
2
3
4
5
6
7
8
9

>>> from collections.abc import Iterator
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
1
2
3
4
5
6
7
8
9
10
11

正如上面代码所示，列表、字典和字符串都是可迭代的，而数字就不是可迭代的。但列表、字典和字符串都不是迭代器，因为可迭代的对象（如列表、元组、字典、集合和字符串），得先使用 iter() 方法把它们初始化为迭代器对象之后，才能使用 next() 方法对其进行迭代。所以 iter([]) 和iter('abc') 都是迭代器。

有了迭代器之后，就可以用 next() 方法对其进行迭代，如果迭代器的内容已经全部迭代完了，就会返回一个 StopIteration 的错误：

>>> list=[1, 2, 3, 4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>> print (next(it))
3
>>> print (next(it))
4
>>> print (next(it))
Traceback (most recent call last):
  File "", line 1, in <module>
StopIteration
1
2
3
4
5
6
7
8
9
10
11
12
13
14

不断地调用 next() 方法显然太麻烦了，最简洁的方法是使用 for 循环：

>>> for i in [1, 2, 3, 4]:
...     print(i)
... 
1
2
3
4
1
2
3
4
5
6
7

注意 for 循环接收的只是可迭代对象而不是迭代器，所以实际上 for 循环帮我们同时完成了 iter() 和 next() 方法，并且在遇到 StopIteration 就会自动退出循环。以下代码和上面是等价的：

it = iter([1, 2, 3, 4, 5])  # 创建迭代器对象
# 循环:
while True:
    try:
        i = next(it)  # 输出迭代器的下一个元素
        print(i)
    except StopIteration:  # 遇到StopIteration就退出循环
        break
1
2
3
4
5
6
7
8

说完迭代器，就轮到生成器了。所谓生成器（generator） 就是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

生成器（函数）有两种写法，第一种是类似于列表生成式（推导式） 的写法，只不过把列表的中括号换成小括号而已：

>>> f = (x * x for x in range(10))
>>> f
<generator object <genexpr> at 0x1022ef630>
1
2
3

f 就是一个迭代器，其函数为求平方，所以能使用 next() 方法进行迭代：

>>> next(f)
0
>>> next(f)
1
>>> next(f)
4
>>> next(f)
9
>>> next(f)
16
>>> next(f)
25
>>> next(f)
36
>>> next(f)
49
>>> next(f)
64
>>> next(f)
81
>>> next(g)
Traceback (most recent call last):
  File "", line 1, in <module>
StopIteration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

同样地，用 for 循环既然能处理可迭代对象，当然也可以处理迭代器，如下

>>> f = (x * x for x in range(10))
>>> for i in f:
...     print(i)
... 
0
1
4
9
16
25
36
49
64
81
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第二种生成器的写法，就是在创建函数时使用 yield 关键字，假设我们想输出指定长度的斐波拉契数列，有如下函数：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
1
2
3
4
5
6
7

调用函数如下：

>>> fib(6)
1
1
2
3
5
8
'done'
1
2
3
4
5
6
7
8

只需要把函数中的 print 改为 yield，该函数就变成了生成器函数：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
1
2
3
4
5
6
7

调用生成器函数就会得到一个生成器，实际上也就是迭代器：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>
1
2
3

所以用 for 循环进行迭代可以得到如下结果：

>>> for i in f:
...     print(i)
... 
1
1
2
3
5
8
1
2
3
4
5
6
7
8
9

生成器函数和普通函数的执行流程不一样。普通函数是顺序执行，遇到 return 语句或者最后一行函数语句就返回。而变成生成器的函数，在每次调用 next() 的时候执行，遇到 yield 语句返回，再次执行时从上次返回的 yield 语句处继续执行。

最后作个总结：

• 迭代器一定是可迭代的，但集合数据类型如列表、字典、字符串等是可迭代的但不是迭代器，可以通过 iter() 函数获得一个迭代器对象；
• 凡是可作用于 for 循环的对象都是可迭代的；
• 凡是可作用于 next() 函数的对象都是迭代器，它们表示一个惰性计算的序列；
• Python 的 for 循环如果接收到还不是迭代器的可迭代的对象，就会调用 iter() 将其变成迭代器，然后不断调用 next() 函数实现迭代过程；
• 生成器就是可以让我们通过编写函数，自定义得到的迭代器。