一文说清Python可迭代对象，迭代器，生成器的关系

Python的初学者可能会对以下概念感到困惑&＃xff1a;

• 容器
• 可迭代对象
• 迭代器
• 生成器
• 生成器表达式

这篇文章将有助于加深对上述概念的理解&＃xff0c;并梳理它们之间的异同之处。

容器

容器是一种数据结构&＃xff0c;它可收纳元素&＃xff0c;并支持成员关系判断。它们是存储在内存中的数据结构&＃xff0c;通常在内存中维持着元素。在Python中&＃xff0c;它们包括&＃xff1a;

• list , deque,…
• set , fronzensets,…
• dict , defaultdict, OrderedDict, Counter,…
• str

此处的容器&＃xff0c;跟日常生活中容器的概念是相似的&＃xff0c;比如一个盒子&＃xff0c;一间房子&＃xff0c;一艘船等。

技术上而言&＃xff0c;当询问一个对象是否包含某个元素时&＃xff0c;该对象就是容器。因此&＃xff0c;可将诸如成员关系判断的方法&＃xff0c;应用于容器中。

比如&＃xff1a;list、sets、tuples&＃xff1a;

>>> assert 1 in [1, 2, 3] # lists
>>> assert 4 not in [1, 2, 3]
>>> assert 1 in {1, 2, 3} # sets
>>> assert 4 not in {1, 2, 3}
>>> assert 1 in (1, 2, 3) # tuples
>>> assert 4 not in (1, 2, 3)


而dict的成员关系判断&＃xff0c;则是判断key&＃xff1a;

>>> d &＃61; {1: &＃39;foo&＃39;, 2: &＃39;bar&＃39;, 3: &＃39;qux&＃39;}
>>> assert 1 in d
>>> assert 4 not in d
>>> assert &＃39;foo&＃39; not in d # &＃39;foo&＃39; is not a _key_ in the dict


如果判断dict的value&＃xff0c;则可使用&＃xff1a;

>>> assert &＃39;foo&＃39; in d.values()


而字符串str&＃xff0c;也是包含着元素&＃xff0c;支持成员关系判断。因此它也属于容器&＃xff1a;

>>> s &＃61; &＃39;foobar&＃39;
>>> assert &＃39;b&＃39; in s
>>> assert &＃39;x&＃39; not in s
>>> assert &＃39;foo&＃39; in s # a string "contains" all its substrings


实际上&＃xff0c;当使用成员关系判断时&＃xff0c;是调用了该对象的类方法__contains__&＃xff0c;如果没有实现此方法&＃xff0c;则调用对象的类方法__iter__。也就是说&＃xff0c;大多数容器对象&＃xff0c;都提供了这两种方法或其一。

尽管大多数容器提供了一种迭代出每个元素的能力&＃xff0c;但并非只有容器才具有这种能力。准确而言&＃xff0c;具有这种能力(迭代出元素)的对象&＃xff0c;称为可迭代对象&＃xff0c;也就是说&＃xff0c;实现了__iter__方法的对象&＃xff0c;为可迭代对象。

通常而言&＃xff0c;大多数容器是可迭代对象。

可通过下面例子加深理解&＃xff1a;

• 是容器&＃xff0c;支持成员关系判断&＃xff0c;但不是可迭代对象&＃xff1a;

  class Foo:def __init__(self,item):self.item &＃61; itemdef __contains__(self, *args):print("membership testing...")return args[0] in self.itemf &＃61; Foo([1,2,3,4])
print(1 in f) # 成员关系判断&＃xff0c;调用了__containers__方法
print(100 in f) # 同上
---for ele in f: # 迭代&＃xff0c;调用了__iter__方法。因为没有定义&＃xff0c;因此是不可迭代对象print(ele)


  输出&＃xff1a;

  membership testing...
True
membership testing...
False
--
Traceback (most recent call last):File "E:/PyProject/test02.py", line 14, in for ele in f:
TypeError: &＃39;Foo&＃39; object is not iterable


• 是容器&＃xff0c;支持成员关系判断&＃xff0c;是可迭代对象&＃xff1a;

  class Foo:def __init__(self,item):self.item &＃61; itemself.iter &＃61; iter(item)def __contains__(self, *args):print("membership testing...")return args[0] in self.itemdef __iter__(self):print(&＃39;Ready to iter...&＃39;)return self.iterf &＃61; Foo([1,2,3,4])for ele in f: # 是可迭代对象&＃xff0c;因此可迭代print(ele)


  输出&＃xff1a;

  Ready to iter...
1
2
3
4


容器中不是可迭代对象的类&＃xff0c;比如Bloom filter。虽然Bloom filter可以用来检测某个元素是否包含在容器中&＃xff0c;但是并不能从容器中获取其中的每一个值&＃xff0c;也就是无法迭代。

因为Bloom filter压根就没把元素存储在容器中&＃xff0c;而是通过一个散列函数映射成一个值保存在数组中。

可迭代对象

如上文所述&＃xff0c;大多数容器都是可迭代对象。但不仅于此&＃xff0c;如打开的文件&＃xff0c;打开数sockets也是可迭代对象。

通常情况下&＃xff0c;容器所包含的数据是有限的。而可迭代对象却可以是无穷的数据源。

一个可迭代对象可以是任何一种对象&＃xff0c;并不仅限于是一种数据结构。只要提供了__iter__方法的对象&＃xff0c;都是可迭代对象。

一般来说&＃xff0c;能够返回一个迭代器的对象&＃xff0c;都是可迭代对象。因为没有人定义了一个迭代器&＃xff0c;但却无法迭代。

迭代器的目标&＃xff0c;就是返回它所包含的全部元素。

比如下面的例子&＃xff1a;

>>> x &＃61; [1, 2, 3] # 可迭代对象
>>> y &＃61; iter(x)
>>> z &＃61; iter(x) # 返回了迭代器对象
>>> next(y)
1
>>> next(y)
2
>>> next(z)
1
>>> type(x)

>>> type(y)



此处&＃xff0c;x是可迭代对象&＃xff0c;而y和z是两个独立的迭代器实例&＃xff0c;可以从可迭代对象x中生产出元素。可以使用内建函数next(iterator,[default])来判断一个对象是否是迭代器。

y和z会维持一种状态。该状态用于记录当前迭代所在的位置&＃xff0c;以方便下次迭代的时候获取正确的元素。

总结&＃xff1a;

如果一个可迭代对象的类支持__iter__()和__next__()方法&＃xff0c;并且__iter__()返回self&＃xff0c;这会使得类既是一个可迭代对象&＃xff0c;也是自己的迭代器。不过&＃xff0c;最好返回一个与迭代器不同的对象。

也就是说&＃xff0c;迭代时&＃xff0c;会调用__iter__方法&＃xff0c;返回一个新的迭代器对象。当然也可以自定义返回的对象。

最后&＃xff0c;迭代元素时&＃xff1a;

x &＃61; [1, 2, 3]
for elem in x:...


实际上的过程是&＃xff1a;

当你反编译这段Python代码时&＃xff0c;你会看到解释器显式地调用GET_ITER&＃xff0c;这本质上就是调用iter(x)。FOR_ITER指令会调用等效于next()去重复获取每个元素&＃xff0c;但这并没有在字节码指令中显示出来&＃xff0c;因为这被解释器优化过了。

>>> import dis
>>> x &＃61; [1, 2, 3]
>>> dis.dis(&＃39;for _ in x: pass&＃39;)1 0 SETUP_LOOP 14 (to 17)3 LOAD_NAME 0 (x)6 GET_ITER>> 7 FOR_ITER 6 (to 16)10 STORE_NAME 1 (_)13 JUMP_ABSOLUTE 7>> 16 POP_BLOCK>> 17 LOAD_CONST 0 (None)20 RETURN_VALUE


迭代器

那什么是迭代器呢&＃xff1f;它是一个对象&＃xff0c;当你调用next()时会有效地迭代出(生产出)一个值。

任何实现了__next__()方法的对象&＃xff0c;都是一个迭代器。因此&＃xff0c;迭代器是一个生产值的工厂。每次你询问下一个值时&＃xff0c;它将会知道如何计算此值&＃xff0c;因为它维持了内部的状态。

有很多关于迭代器的例子&＃xff0c;所有itertools函数都返回迭代器&＃xff0c;比如生成无限的序列&＃xff1a;

>>> from itertools import count
>>> counter &＃61; count(start&＃61;13)
>>> next(counter)
13
>>> next(counter)
14


比如从有限序列中循环返回序列&＃xff1a;

>>> from itertools import cycle
>>> colors &＃61; cycle([&＃39;red&＃39;, &＃39;white&＃39;, &＃39;blue&＃39;])
>>> next(colors)
&＃39;red&＃39;
>>> next(colors)
&＃39;white&＃39;
>>> next(colors)
&＃39;blue&＃39;
>>> next(colors)
&＃39;red&＃39;


为了更直观地理解迭代器的内部执行过程&＃xff0c;我们定义了一个产生斐波那契数列的迭代器

>>> class fib:
... def __init__(self):
... self.prev &＃61; 0
... self.curr &＃61; 1
...
... def __iter__(self):
... return self
...
... def __next__(self):
... value &＃61; self.curr
... self.curr &＃43;&＃61; self.prev
... self.prev &＃61; value
... return value
...
>>> f &＃61; fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]


需要注意的是&＃xff0c;这个类既是可迭代对象&＃xff0c;也是迭代器。因为它实现了__iter__()和__next__()方法。

此迭代器内部的状态由pre和curr的实例变量来维持&＃xff0c;并用于调用迭代器时产生的下一个序列。每次调用next()&＃xff0c;会做两件事&＃xff1a;

1. 为下一次next()调用而修改状态
2. 生产出当前调用的结果

从类的外部来看&＃xff0c;迭代器相当于一个懒惰的工厂。它只有在需要值的时候才生产出值。当生产出一个值后&＃xff0c;将停止生产直到你下一次调用它。这就是懒加载。

生成器

生成器可以算得上是Python中最吸引人的语言特性之一&＃xff0c;它实际上是一种特殊的迭代器&＃xff0c;但更加优雅。

一个生成器允许你编写一个类似于斐波那契数列的迭代器&＃xff0c;但它简洁优雅的语法允许你无需提供__iter__()和__next__()方法。

可以理解为&＃xff0c;使用yield关键字的函数&＃xff0c;就是生成器函数。

因此可以概括为&＃xff1a;

• 生成器也是迭代器。
• 生成器是一个懒加载的工厂函数。

下面的代码使用生成器实现了斐波那契数列的工厂函数&＃xff1a;

>>> def fib():
... prev, curr &＃61; 0, 1
... while True:
... yield curr
... prev, curr &＃61; curr, prev &＃43; curr
...
>>> f &＃61; fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]


代码说明&＃xff1a;

1. fib是一个普通的Python函数&＃xff0c;但它没有包含return关键字。
2. fib的函数返回值是一个生成器(迭代器&＃xff0c;工厂函数)
3. 当f &＃61; fib() 被调用&＃xff0c;生成器被实例化并返回。此时并没有执行任何代码&＃xff0c;也就是说prev,curr &＃61; 0, 1并没有执行。
4. 生成器实例被islice()包装&＃xff0c;这也是一个迭代器&＃xff0c;因此最初时是空闲状态&＃xff0c;没有任何事情发生。
5. 然后&＃xff0c;迭代器被list()包装&＃xff0c;它是一个消费者&＃xff0c;消费它所包含的参数并从中构建成 一个列表的形式。此时&＃xff0c;将在islice()实例中调用next()方法&＃xff0c;并在f中调用next()方法。
6. 此时&＃xff0c;代码开始真正执行&＃xff0c;进入到循环中&＃xff0c;直到遇到yield&＃xff0c;产生一个值后&＃xff0c;将再次进入空闲状态。
7. 产生的值传递给islice()&＃xff0c;并生产出来。list增加值1到列表中。
8. 然后循环往复&＃xff0c;直到输出列表的长度为10个元素
9. 求第11个值时&＃xff0c;islice&＃xff08;&＃xff09;将引发StopIteration异常&＃xff0c;表明已到达末尾&＃xff0c;并且list将返回结果&＃xff1a;list 10个项。其中包含前10个斐波那契数。 请注意&＃xff0c;生成器没有收到第11个next&＃xff08;&＃xff09;调用。 实际上&＃xff0c;它不会再次使用&＃xff0c;以后会被垃圾回收。

生成器是程序结构中非常有效的工具&＃xff0c;它允许你使用很少的中间变量和数据结构来编写流式代码。并且&＃xff0c;它们在CPU和内存的表现中更为高效&＃xff0c;代码更为简洁。

但凡看到下面的代码&＃xff0c;都可用生成器重构&＃xff1a;

def something():result &＃61; []for ... in ...:result.append(x)return result


生成器&＃xff1a;

def iter_something():for ... in ...:yield x# def something(): # Only if you really need a list structure
# return list(iter_something())


生成器表达式

在Python中的生成器有两类&＃xff1a;生成器函数和生成器表达式。

生成器函数是拥有yield关键字的函数。

生成器表达式是列表解析式的生成器版本&＃xff0c;看起来像列表解析式&＃xff0c;但是它返回的是一个生成器对象而不是列表对象。

比如列表解析式&＃xff0c;集合解析式和字典解析式&＃xff1a;

>>> numbers &＃61; [1, 2, 3, 4, 5, 6]
>>> [x * x for x in numbers]
[1, 4, 9, 16, 25, 36]>>> {x * x for x in numbers}
{1, 4, 36, 9, 16, 25}>>> {x: x * x for x in numbers}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}


生成器表达式&＃xff1a;

>>> a &＃61; (x*x for x in range(10))
>>> a
at 0x401f08>
>>> sum(a) ## 已经消费完a里面的值
285
>>> a &＃61; (x*x for x in range(10))
>>> next(a) ## 开始消费
0
>>> list(a)
[1,2,3,4,5,6,7,8,9]


总结&＃xff1a;

在实际使用过程汇总&＃xff0c;如果需要延迟计算&＃xff0c;懒加载的场景&＃xff0c;使用生成器更加节省内存资源&＃xff0c;而且CPU利用效率更高。

参考&＃xff1a;https://nvie.com/posts/iterators-vs-generators/