文章目录
第四章 面向对象编程–可迭代的对象、迭代器和生成器
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()