搞清楚 Python 的迭代器、可迭代对象、生成器

不少伙伴对 Python 的迭代器、可迭代对象、生成器这几个概念有点搞不清楚，我来讲说个人理解，但愿对须要的朋友有所帮助。

1 迭代器协议

迭代器协议是核心，搞懂了这个，上面的几个概念也就很好理解了。

所谓迭代器协议，就是要求一个迭代器必需要实现以下两个方法

iterator.__iter__()
Return the iterator object itself.

iterator.__next__()
Return the next item from the container.

也就是说，一个对象只要支持上面两个方法，就是迭代器。__iter__() 须要返回迭代器自己，而 __next__() 须要返回下一个元素。

2 可迭代对象

知道了迭代器的概念，那可迭代对象又是啥呢？

这个更简单，只要对象实现了 __iter__() 方法，而且返回的是一个迭代器，那么这个对象就是可迭代对象。

好比咱们常见的列表就是可迭代对象

>>> l = [1, 3, 5]
>>> iter(l)
<list_iterator object at 0x101a1d9e8>

使用 iter() 会调用对应的 __iter__() 方法，这里返回的是一个列表迭代器，因此说列表就是一个可迭代对象。

3 手写一个迭代器

迭代器的实现有不一样的方式，相信你们首先能想到的就是自定义类，咱们就从这个提及。

便于说明，咱们手写一个迭代器，用于生成奇数序列。

按照迭代器协议，咱们实现上述的两个方法。

class Odd:
    def __init__(self, start=1):
        self.cur = start

    def __iter__(self):
        return self

    def __next__(self):
        ret_val = self.cur
        self.cur += 2
        return ret_val

终端里，咱们实例化一个 Odd 类获得一个对象 odd

>>> odd = Odd()
>>> odd
<__main__.Odd object at 0x101a1d9b0>

使用 iter() 方法会调用类里的 __iter__ 方法，获得它自己

>>> iter(odd)
<__main__.Odd object at 0x101a1d9b0>

使用 next() 方法会调用对应的 __next__() 方法，获得下一个元素

>>> next(odd)
1
>>> next(odd)
3
>>> next(odd)
5

其实，odd 对象就是一个迭代器了。

咱们能够用 for 来遍历它

odd = Odd()
for v in odd:
    print(v)

细心的伙伴可能会发现，这个其实会无限的打印下去，那怎么解决呢？

咱们拿一个列表作作实验，先获得它的迭代器对象

>>> l = [1, 3, 5]
>>> li = iter(l)
>>> li
<list_iterator object at 0x101a1da90>

而后手动获取下一个元素，直到没有下一个元素为止，看下会发生什么

>>> next(li)
1
>>> next(li)
3
>>> next(li)
5
>>> next(li)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

原来列表迭代器会在没有下一个元素的时候抛出 StopIteration 异常，估计 for 语句就是根据这个异常来肯定是否结束。

咱们修改一下原来的代码，能生成指定范围内的奇数

class Odd:
    def __init__(self, start=1, end=10):
        self.cur = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.cur > self.end:
            raise StopIteration
        ret_val = self.cur
        self.cur += 2
        return ret_val

咱们使用 for 试一下

>>> odd = Odd(1, 10)
>>> for v in odd:
...     print(v)
...
1
3
5
7
9

果真，和预期一致。

咱们用 while 循环模拟 for 的执行过程

目标代码

for v in iterable:
    print(v)

翻译后的代码

iterator = iter(iterable)
while True:
    try:
        v = next(iterator)
        print(v)
    except StopIteration:
        break

事实上 Python 的 for 语句原理也就是这样，能够将 for 理解为一个语法糖。

4 建立迭代器的其它方式

生成器其实也是迭代器，因此可使用生成器的建立方式建立迭代器。

4.1 生成器函数

和普通函数的 return 返回不一样，生成器函数使用 yield。

>>> def odd_func(start=1, end=10):
...     for val in range(start, end + 1):
...         if val % 2 == 1:
...             yield val
...
>>> of = odd_func(1, 5)
>>> of
<generator object odd_func at 0x101a14200>
>>> iter(of)
<generator object odd_func at 0x101a14200>
>>> next(of)
1
>>> next(of)
3
>>> next(of)
5
>>> next(of)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

4.2 生成器表达式

>>> g = (v for v in range(1, 5 + 1) if v % 2 == 1)
>>> g
<generator object <genexpr> at 0x101a142b0>
>>> iter(g)
<generator object <genexpr> at 0x101a142b0>
>>> next(g)
1
>>> next(g)
3
>>> next(g)
5
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

4.3 怎么选择

到如今为止，咱们知道了建立迭代器的 3 种方式，那么该如何选择？

不用说也知道，最简单的就是生成器表达式，若是表达式能知足需求，那么就是它；若是须要添加比较复杂的逻辑就选生成器函数；若是前二者无法知足需求，那就自定义类实现吧。总之，选择最简单的方式就行。

5 迭代器的特色

5.1 惰性

迭代器并非把全部的元素提早计算出来，而是在须要的时候才计算返回。

5.2 支持无限个元素

好比上面咱们创建的第一个 Odd 类，它的实例 odd 表示大于 start 的全部奇数，而列表等容器无法容纳无限个元素的。

5.3 省空间

好比存 10000 个元素

>>> from sys import getsizeof
>>> a = [1] * 10000
>>> getsizeof(a)
80064

列表占用 80K 左右。

而迭代器呢？

>>> from itertools import repeat
>>> b = repeat(1, times=10000)
>>> getsizeof(b)
56

只占用了 56 个字节。

也正由于迭代器惰性的特色，才有了这个优点。

6 一些须要注意的细节

6.1 迭代器同时也是可迭代对象

由于迭代器的 __iter__() 方法返回了它自身，而正好它自己就是个迭代器，因此说迭代器也是可迭代对象。

6.2 迭代器遍历完一次就不能从头开始了

看一个奇怪的例子

>>> l = [1, 3, 5]
>>> li = iter(l)
>>> li
<list_iterator object at 0x101a1da90>
>>> 3 in li
True
>>> 3 in li
False

由于 li 是列表迭代器，第一次查找 3 的时候，找到了，因此返回 True，可是因为第一次迭代，已经跳过了 3 那个元素，第二次就找不到了，因此会出现 False。

所以，记得迭代器是「一次性」的。

固然，列表是可迭代对象，无论查找几回都是正常的。（很差理解的话，想一想上面 for 语句的执行原理，每次都会从可迭代对象那经过 iter() 方法取到新的迭代器）

>>> 3 in l
True
>>> 3 in l
True

7 小节

• 实现了迭代器协议的对象都是迭代器
• 实现了 __iter__() 方法并返回迭代器的对象是可迭代对象
• 生成器也是一种迭代器
• 建立迭代器有三种方式，生成器表达式、生成器函数、自定义类，看状况选择最简单的就好
• 迭代器同时也是可迭代对象
• 迭代器是「一次性」的

前面 3 小项是重点，这 3 点理解了，其它的也都能领会。搞清楚标题的那几个名词的概念的天然也没有问题。

8 参考

• https://docs.python.org/3/library/stdtypes.html#iterator-types
• https://opensource.com/article/18/3/loop-better-deeper-look-iteration-python
• http://treyhunner.com/2018/06/how-to-make-an-iterator-in-python

原文连接：http://www.kevinbai.com/articles/25.html

关注「小小后端」公众号，更多干货等着你喔！