文章目录
第四章 面向对象编程–可迭代的对象、迭代器和生成器
4.5 可迭代的对象、迭代器和生成器
迭代是数据处理的基石。扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式（ Iterator pattern ）。 Python 内置了迭代器模式，可以避免自己手动去实现。
所有生成器都是迭代器，因为生成器完全实现了迭代器的接口。迭代器用于从集合中取出元素；而生成器用于"凭空"生成元素。
在 Python 中，所有序列都可以迭代。在 Python 语言内部，迭代器用于支持：
for循环；- 构建和扩展集合类型；
- 逐行遍历文本文件；
- 列表推导、字典推导和集合推导；
- 元组拆包；
- 调用函数时，使用
*拆包实参；
4.5.1 为什么Python所有序列都可迭代
之所以所有的序列都可迭代，是因为 iter 内置函数，解释器需要迭代对象时，会自动调用iter(x)，内置的 iter 函数有以下作用：
- 检查对象是否实现了
__iter__方法，如果实现了就调用它，获取一个迭代器。 - 如果没有实现
__iter__方法，但是实现了__getitem__方法，Python会创建一个迭代器，尝试按顺序（从索引0开始）获取元素。 - 如果尝试失败，
Python抛出TypeError异常，通常会提示"C object is not iterable"（C对象不可迭代），其中C是目标对象所属的类。
任何Python序列都可迭代的原因是，它们都实现了 __getitem__ 方法。
4.5.2 可迭代的对象与迭代器的对比
4.5.2.1 iter 内置函数
使用 iter 内置函数可以获取迭代器的对象。如果对象实现了能返回迭代器的 __iter__ 方法，那么对象就是可迭代的。序列都可以迭代，因为都实现了 __getitem__ 方法，而且其参数是从零开始的索引，这种对象也可以迭代。
我们要明确可迭代的对象和迭代器之间的关系： Python 从可迭代的对象中获取迭代器。如下面的 for 循环，迭代一个字符串。这里，字符串’ABC’是可迭代的对象。背后是有迭代器的，只不过我们看不到。如果我们没有 for 语句，不得不使用 while 循环模拟。
s = "ABC"
for char in s:
print(char)
print("-"*30)
it = iter(s) # 1、使用可迭代对象构建迭代器it
while True:
try:
print(next(it)) # 2、不断地在迭代器上调用`next`函数获取下一个字符。
except StopIteration: # 3、如果没有字符了，迭代器会抛出StopIteration异常。
del it # 4、释放对it的引用，即废弃迭代器对象。
break # 5、退出循环
A
B
C
------------------------------
A
B
C
4.5.2.2 iterable 和 iterator
标准的迭代器接口有两个方法。
__next__返回下一个可用的元素，如果没有元素了，抛出StopIteration异常。__iter__返回self，以便在应该使用可迭代对象的地方使用迭代器，例如在for循环中。
这个接口在 collections.abc.Iterator 抽象基类中制定。这个类定义了 __next__ 抽象方法，而且继承自 Iterable 类； __iter__ 抽象方法则在 Iterable 类中定义。如下图所示。 Iterable 和 Iterator 抽象基类。以斜体显示的是抽象方法。具体的 Iterable.__iter__ 方法应该返回一个 Iterator 实例。具体的 Iterator 类必须实现 __next__ 方法。 Iterator.__iter__ 方法直接返回实例本身
class Iterator(Iterable):
__slots__ = ()
@abstractmethod
def __next__(self):
'Return the next item from the iterator. When exhausted, raise StopIteration'
raise StopIteration
def __iter__(self):
return self
@classmethod
def __subclasshook__(cls, C):
if cls is Iterator:
if (any("__next__" in B.__dict__ for B in C.__mro__) and
any("__iter__" in B.__dict__ for B in C.__mro__)):
return True
return NotImplemented
4.5.2.3 Sentence 实例
所以，迭代器是这样的对象：
- 实现了无参数的
__next__方法，返回序列中的下一个元素； - 如果没有元素了，那么抛出
StopIteration异常。Python中的迭代器还实现了__iter__方法，因此迭代器也可以迭代。
注意，下面代码是典型地迭代器模式，不过不符合 python 的习惯做法。不过，通过这一版能明确可迭代的集合和迭代器对象之间的关系。定义的 Sentence 类可以迭代，因为它实现了特殊的 __iter__ 方法，构建并返回一个 SentenceIterator 实例。这样，我们就很清楚地看到可迭代的对象和迭代器之间的重要区别，以及二者之间的联系。
注意不要把 Sentence 变成迭代器。要知道，可迭代的对象有个 __iter__ 方法，每次都实例化一个新的迭代器；而迭代器要实现 __next__ 方法，返回单个元素，此外还要实现 __iter__ 方法，返回迭代器本身。因此，迭代器可以迭代，但是可迭代的对象不是迭代器。
除了 __iter__ 方法之外，你可能还想在 Sentence 类中实现 __next__ 方法，让 Sentence 实例既是可迭代的对象，也是自身的迭代器。这样做非常糟糕，因为很多时候，我们需要从同一个可迭代对象中获取多个独立的迭代器，而且各个迭代器要能维护自身的内部状态，因此这一模式正确的实现方式是，每次调用 iter(my_iterable) 都新建一个独立的迭代器。这就是为什么这个示例需要定义 SentenceIterator 类。
import re
import reprlib
RE_WORD = re.compile('\w+')
class Sentence:
def __init__(self, text):
self.text = text
self.words = RE_WORD.findall(text)
def __repr__(self):
return 'Sentence(%s)' % reprlib.repr(self.text)
def __iter__(self):
return SentenceIterator(self.words)
class SentenceIterator:
def __init__(self, words):
self.words = words
self.index = 0
def __next__(self):
try:
word = self.words[self.index]
except IndexError:
raise StopIteration()
self.index += 1
return word
def __iter__(self):
return self
# 1、传入一个字符串，创建一个Sentence实例
s = Sentence('"The time has come," the Walrus said,')
print(s) # 2、注意，__repr__方法的输出中包含reprlib.repr方法生成的...。
for word in s: # 3、Sentence实例可以迭代
print(word)
print(list(s)) # 4、因为可以迭代，所以Sentence对象可以用于构建列表和其他可迭代的类型
Sentence('"The time ha... Walrus said,')
The
time
has
come
the
Walrus
said
['The', 'time', 'has', 'come', 'the', 'Walrus', 'said']
4.5.3 生成器函数
实现 Sentence 相同功能，但却符合 Python 习惯的方式是，可以用生成器函数代替 SentenceIterator 类。在下面的代码中，迭代器其实是生成器对象，每次调用__iter__方法都会自动创建，因为这里的__iter__方法是生成器函数。
import re
import reprlib
RE_WORD = re.compile('\w+')
class Sentence:
def __init__(self, text):
self.text = text
self.words = RE_WORD.findall(text)
def __repr__(self):
return 'Sentence(%s)' % reprlib.repr(self.text)
def __iter__(self):
for word in self.words: # 1、迭代self.words。
yield word # 2、产出当前的word。
return
# 1、传入一个字符串，创建一个Sentence实例
s = Sentence('"The time has come," the Walrus said,')
print(s) # 2、注意，__repr__方法的输出中包含reprlib.repr方法生成的...。
for word in s: # 3、Sentence实例可以迭代
print(word)
print(list(s)) # 4、因为可以迭代，所以Sentence对象可以用于构建列表和其他可迭代的类型
Sentence('"The time ha... Walrus said,')
The
time
has
come
the
Walrus
said
['The', 'time', 'has', 'come', 'the', 'Walrus', 'said']
4.5.3.1 生成器函数的工作原理
只要 Python 函数的定义体中有 yield 关键字，该函数就是生成器函数。调用生成器函数时，会返回一个生成器对象。也就是说，生成器函数是生成器工厂。
PEP 255 – Simple Generators
调用生成器函数返回生成器；生成器产出或生成值。生成器不会以常规的方式"返回"值：生成器函数定义体中的 return 语句会触发生成器对象抛出 StopIteration 异常。
def gen_123(): # 1、只要Python函数中包含关键字yield，该函数就是生成器函数
yield 1 # 2、生成器函数的定义体中通常都有循环，不过这不是必要条件；这里我重复使用3次yield。
yield 2
yield 3
print(gen_123) # 3、仔细看，gen_123是函数对象。
print(gen_123()) # 4、但是调用时，gen_123( )返回一个生成器对象
for i in gen_123(): # 5、生成器是迭代器，会生成传给yield关键字的表达式的值
print(i)
g = gen_123() # 6、为了仔细检查，我们把生成器对象赋值给g。
print(next(g)) # 7、因为g是迭代器，所以调用next(g)会获取yield生成的下一个元素。
print(next(g))
print(next(g))
print(next(g)) # 8、生成器函数的定义体执行完毕后，生成器对象会抛出StopIteration异常。
<function gen_123 at 0x000002489586F040>
<generator object gen_123 at 0x0000024895711040>
1
2
3
1
2
3
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
Cell In [5], line 15
13 print(next(g))
14 print(next(g))
---> 15 print(next(g)) # 8、生成器函数的定义体执行完毕后，生成器对象会抛出StopIteration异常。
StopIteration:
4.5.3.2 生成器表达式
生成器表达式可以理解为列表推导的惰性版本：不会迫切地构建列表，而是返回一个生成器，按需惰性生成元素。也就是说，如果列表推导是制造列表的工厂，那么生成器表达式就是制造生成器的工厂。
def gen_AB():
print('start')
yield 'A'
print('continue')
yield 'B'
print('end.')
# 1、列表推导迫切地迭代gen_AB()函数生成的生成器对象产出的元素：'A'和'B'。注意，同时输出start、continue和end.。
res1 = [x*3 for x in gen_AB()]
print("*"*25)
for i in res1: # 2、这个for循环迭代列表推导生成的res1列表
print('-->', i)
print("*"*27)
# 3、把生成器表达式返回的值赋值给res2。只需调用gen_AB()函数，虽然调用时会返回一个生成器，但是这里并不使用。
res2 = (x*3 for x in gen_AB())
print(res2) # 4、res2是一个生成器对象
# 5、只有for循环迭代res2时，gen_AB函数的定义体才会真正执行。for循环每次迭代时会隐式调用next(res2)，前进到gen_AB函数中的下一个yield语句。注意，gen_AB函数的输出与for循环中print函数的输出夹杂在一起。
for i in res2:
print('-->', i)
start
continue
end.
*************************
--> AAA
--> BBB
***************************
<generator object <genexpr> at 0x00000248956CF820>
start
--> AAA
continue
--> BBB
end.
4.5.3.3 Sentence：惰性实现
设计 Iterator 接口时考虑到了惰性： next(my_iterator) 一次生成一个元素。懒惰的反义词是急迫，其实，惰性求值（ lazy evaluation ）和及早求值（ eager evaluation ）是编程语言理论方面的技术术语。目前实现的 Sentence 类不具有惰性，因为 __init__ 方法急迫地构建好了文本中的单词列表，然后将其绑定到 self.words 属性上。这样就得处理整个文本，列表使用的内存量可能与文本本身一样多（或许更多，这取决于文本中有多少非单词字符）。如果只需迭代前几个单词，大多数工作都是白费力气。如下，使用了 RE_WORD.finditer ，省略了 self.words 占用的内存。
import re
import reprlib
import doctest
RE_WORD = re.compile('\w+')
class Sentence:
"""
1、传入一个字符串，创建一个Sentence实例，注意，__repr__方法的输出中包含reprlib.repr方法生成的...
>>> s = Sentence('"The time has come," the Walrus said,')
>>> s
Sentence('"The time ha... Walrus said,')
2、Sentence实例可以迭代
>>> [word for word in s]
['The', 'time', 'has', 'come', 'the', 'Walrus', 'said']
3、因为可以迭代，所以Sentence对象可以用于构建列表和其他可迭代的类型
>>> list(s)
['The', 'time', 'has', 'come', 'the', 'Walrus', 'said']
"""
def __init__(self, text):
self.text = text
def __repr__(self):
return 'Sentence(%s)' % reprlib.repr(self.text)
def __iter__(self):
return (match.group() for match in RE_WORD.finditer(self.text))
if __name__ == "__main__":
doctest.testmod()