Python 进阶之生成器与迭代器

发表于 | 分类于 | | 阅读次数:
字数统计: 3.9k | 阅读时长 ≈ 0:04

迭代器（Iterators）和生成器（Generators）是 Python 语言中用处很大的工具，在某些情况下通过它们可以写出更加精简、清晰和高效的代码。

迭代器

迭代器是一种包含 __next__ 方法、用于处理数据流的对象。当使用 for 循环之类的方式遍历迭代器中的每一项数据时，__next__ 方法即被重复性地调用进而完成特定的动作。

以下代码即为一个不完整的迭代器类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MultiplyByTwo:
    def __init__(self, number):
        self.number = number
        self.counter = 0

    def __next__(self):
        self.counter += 1
        return self.number * self.counter

mul = MultiplyByTwo(5)
print(next(mul))    # => 5
print(next(mul))    # => 10
print(next(mul))    # => 15
print(next(mul))    # => 20

通过 next() 函数手动调用 MultiplyByTwo 类的 __next__ 方法，可以依次得到 number 变量与递增的 counter 变量的乘积。但是作为一个可被遍历的迭代器类，理论上也应该可以通过 for 语句直接以循环的方式逐次取出 __next__ 返回的乘积。

此时运行如下代码对 MultiplyByTwo 类进行迭代操作：

1
2
for num in MultiplyByTwo(5):
    print(num)

则会报出 TypeError: 'MultiplyByTwo' object is not iterable 错误。即此时的“迭代器”对象还不支持遍历操作。

需要在 MultiplyByTwo 类中添加 __iter__ 方法表明其“可被遍历”，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MultiplyByTwo:
    def __init__(self, number):
        self.number = number
        self.counter = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        return self.number * self.counter

for num in MultiplyByTwo(5):
    print(num)
# => 5
# => 10
# => 15
# => 20
# => ...

此时则可以使用 for 语句循环地调用 __next__ 方法获取 number 和递增的 counter 变量的乘积。
比较尴尬的是，以上面的方式遍历 MultiplyByTwo 迭代器，for 循环会一直运行下去。

可以通过以下代码为前面的迭代器添加终止点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class MultiplyByTwo:
    def __init__(self, number, limit):
        self.number = number
        self.limit = limit
        self.counter = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        value = self.number * self.counter

        if value > self.limit:
            raise StopIteration
        else:
            return value

for num in MultiplyByTwo(5, 20):
    print(num)

# => 5
# => 10
# => 15
# => 20

所以一个实现了 __next__ 方法（用以不断返回下一个数据）、可进行迭代操作的对象即为迭代器。

对于前面实现的 MultiplyByTwo 迭代器类，在用 for 循环进行遍历操作时，
for num in MultiplyByTwo(5, 20): 的最终结果等同于 for 语句对以下列表的遍历：
for num in [5 * 1, 5 * 2, 5 * 3, 5 *4]: 。

实际上，迭代器对象表示的是一个数据流，其可以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 异常。但这个“数据流”不是原本就完整地存在的，只能通过 next() 函数逐次地计算下一个值。
即迭代器的计算是惰性的，只有在需要返回下一个数据时才会被动地进行计算。

生成器

生成器可以理解为一种实现了迭代器协议的数据结构。前面提到迭代器是“懒惰”的，一次只计算一个数据。对于项目体量非常庞大的数据集合（比如全体自然数？没有任何一个列表能装下）或文件，生成器相比于其他数据结构，能够更加高效地使用内存资源。

生成器代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def multiple_generator(num, limit):
    counter = 1
    value = num * counter

    while value <= limit:
        yield value
        counter += 1
        value = num * counter

for num in multiple_generator(5, 20):
    print(num)
# => 5
# => 10
# => 15
# => 20

不同于前面的 MultiplyByTwo 类，此次的 multiple_generator 生成器函数并不需要实现 __next__ 和 __iter__ 方法，也不用检查内部状态确认是否发起异常。而是使用了 yield 关键字。
yield 关键字类似于 return，只不过它并不会终止函数的运行。而是暂时中断函数的执行，直到下一个数据被请求（就继续返回下一个值）。
因此生成器相对于一般的迭代器更加易读和高效。

以下是一个经典的生成器在现实中的应用，通过生成器以数据块的方式读取文件：

1
2
3
4
5
6
7
8
9
10
11
def read_in_chunks(file_handler, chunk_size=1024):
    """ Lazy function (generator) to read a file piece by piece."""
    while True:
        data = file_handler.read(chunk_size)
        if not data:
            break
        yield data

f = open('large_number_of_data.dat')
for piece in read_in_chunks(f):
    print(piece)

通过生成器每次只读取 1k 大小的数据块，循环遍历直到整个文件被处理。而不是将所有文件数据一次性地读入到内存中。
当需要读取的文件非常大时，此种方式相对于常规手段更加节省内存的使用。

yield from

yield from 关键字可以用来从其他生成器中获取数据。参考如下代码：

1
2
3
4
5
6
7
8
9
10
def flat_list(iter_values):
    """flatten a multi list or something"""
    for item in iter_values:
        if hasattr(item, '__iter__'):
            yield from flat_list(item)
        else:
            yield item

print(list(flat_list([1, 2, [3, 4, [5]], 6])))
# => [1, 2, 3, 4, 5, 6]

上面的短短 6 行代码可以将包含任意层次的可迭代对象（如列表等）转换成单层的列表结构。
个人感觉，这代码非常漂亮，有点层层递进、环环相扣的感觉了。值得好好观赏。

PS：可以对比下阶乘的实现代码：

1
2
3
4
5
def factorial(n):
    if n != 1:
        return n * factorial(n-1)
    else:
        return 1

参考资料

Clean Python