- 写 python 很久了,迭代器和生成器这块一直没深入了解,本文从迭代角度简单捋一下相关概念,不会很全面
- 参考:
- python之迭代器和生成器全解–包含实现原理及应用场景
- 《流畅的Python》第 14 章
文章目录
1. 可迭代对象
1.1 基础概念
-
可迭代对象
:python 中可以通过for...in...
语法从中迭代地依次返回数据的对象称为可迭代对象,python 内置的列表、元组、字典、集合、字符串等类型的对象都是可迭代对象
-
当 python 需要迭代对象 x 时,会调用内置方法
iter(x)
,该方法返回 x 的迭代器对象,这会按照以下流程进行- 检查对象是否是实现了
__iter__
方法,如果实现了就调用它,这会返回一个迭代器 - 如果没有实现
__iter__
,则检查对象是否实现了__getitem__
方法,如果实现了就创建一个迭代器,尝试按顺序(从索引 0 开始)获取元素 - 如果尝试失败,抛出异常
TypeError
,通常会提示x object is not iterable
根据鸭子类型的思想,只要实现了
__iter__
方法,或者实现了__getitem__
方法且其参数是从 0 开始的整型数,就可以认为对象是可迭代的 - 检查对象是否是实现了
-
早期的 python 中没有迭代器的概念,迭代工作主要靠序列完成
准确说是靠序列中的
__getitem__
方法,该方法允许按照下标索引,如x[index]
举例来说,
for
循环中的range
函数过去会直接展开成列表,这很可能造成严重的内存问题。随着 python 引入迭代器的概念,现在的迭代场景几乎都改成由迭代器或生成器支持的了,包括- for 循环
- 构建和扩展集合类型
- 逐行遍历文本文件
- 列表推导、字典推导、集合推导
- 元组拆包
- 调用函数时,用
*
拆包实参
python 序列都是可迭代的,这是因为序列的协议中规定了必须实现
__getitem__
方法,随着迭代器概念的引入,现在这些序列类型也都实现了__iter__
方法,之所以仍然支持从__getitem__
方法生成迭代器,主要是为了向后兼容,这一点未来可能不再支持
1.2 基于 __getitem__
生成可迭代对象
1.2.1 只实现 __getitem__
-
只要实现
__getitem__
就能进行迭代,标准写法如下,迭代时从 0 开始直到越界class A: def __init__(self): self.data=[1,2,3] def __getitem__(self,index): return self.data[index] a=A() for i in a: print(i) # 输出为 1、2、3
如果这里进一步实现
__len__
,就得到的标准的序列类 -
这里
__getitem__
也可以不按照上述标准写法来,这会改变迭代的行为,比如# 下面这样写,for 循环打印 2、3 def __getitem__(self,index): return self.data[index+1] # 下面这样写,任意索引 i 都有 a[i] 返回1,上面的 for 循环无限打印 1 def __getitem__(self,index): return self.data[0] # 下面这样写,任意索引 a[x] 返回 `test`,上面的 for 循环无限打印 test def __getitem__(self,index): return 'test'
1.2.2 同时实现 __getitem__
和 __iter__
-
如果同时实现了
__getitem__
和__iter__
,则迭代时会忽略__getitem__
,只按__iter__
来执行class A: def __init__(self): self.data=[1,2,3] self.data1=[4,5,6] def __iter__(self): return iter(self.data1) def __getitem__(self,index): return self.data[index] a=A() for i in a: print(i) # 输出为 4、5、6
-
注意
__iter__
方法要返回一个迭代器,如果这里写一个别的迭代器返回,也会改变迭代的行为,就像 1.2.1 节那样
2. 迭代器
- 迭代器主要是为了实现一种惰性获取数据的方式,即需要多少就计算/获取多少,当扫描内存中存储不了的数据集时,这种思想非常重要。举例来说,要打印前 n 个有理数,有理数数量是无限的,我们不可能先计算并存储所有的有理数,再取前 n 个打印,这时就需要惰性计算,要多少算多少
- 最近在学 Haskell,这就是一种建立在惰性计算性质上的语言,可以特别方便地使用递归表示无穷序列,python 中的迭代器/生成器允许 python 也具备这种能力
2.1 迭代器接口
- 标准的迭代器接口要实现两个方法
__iter__
:返回self
(注意自己本身就是一个迭代器了),以便在应该使用可迭代对象的地方使用迭代器,比如 for 循环中。执行iter(x)
会调用对象x
所属类别的该方法得到一个迭代器对象__next__
:返回下一个可用的元素,如果没有元素了,抛出StopIteration
异常。执行next(x)
会调用对象x
所属类别的该方法得到下一个迭代元素。具体实现时,迭代器对象实例的内部变量会不断记录上次推导的返回值,调用__next__
方法时根据记录的上次返回值及推导算法,计算并返回下一个推导值
- 该接口在
collections.abc.Iterator
抽象基类中制定,该类定义了__next__
抽象方法,且继承自Iterable
类;__iter__
抽象方法则在Iterable
类中定义,如下图所示
2.2 从可迭代对象生成迭代器(for 循环的本质)
-
给出一个简单的 for 循环迭代字符串的例子
S = 'ABC' for char in S: print(char,end=' ') # 打印 A B C
-
注意字符串是可迭代对象,上述 for 循环的背后其实有一个我们看不到的迭代器,for 机制其实做了以下几件事
- 根据
ABC
所属 String 类的__iter__
方法得到其对应的迭代器 - 不断在迭代器上调用
__next__
方法,迭代地获取字符打印 - 遍历完成后撤掉迭代器对象
可以使用 while 循环模拟上述过程如下
S = 'ABC' it = iter(S) while True: try: print(next(it),end=' ') except StopIteration: del it break
- 根据
-
因为迭代器只需要
__iter__
和_next__
两个方法,所以除了调用next()
方法,以及捕获StopIteration
异常外,无法
检查是否还有遗留的元素,也没有办法 “还原” 迭代器,如果想再次迭代只能重新用iter()
创建迭代器
2.3 创建标准的迭代器
-
本节根据 《设计模式:可复用面向对象软件的基础》一书给出的模型实现典型的迭代器设计模式,注意本节的实现并不符合 python 的习惯写法,但是可以清晰地表现出迭代器与可迭代对象的关系,要实现本节相同的功能,使用生成器更符合 python 的习惯,见本文 3.2 节
-
以下程序我们创建一个可迭代对象类
Sentence
,以及它对应的迭代器类SentenceIterator
class Sentence: def __init__(self,text): self.words = text.split(' ') 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
上述实现中有一些冗余,比如
SentenceIterator
中没必要实现__iter__
,但是我们还是实现了它以满足标准格式。下面做一个二重 for 循环S = Sentence('one two three') for word1 in S: for word2 in S: print(word1,word2) ''' one one one two one three two one two two two three three one three two three three '''
-
需要注意的是:不要混淆迭代器和可迭代对象
- 迭代器是为了迭代可迭代对象而创建的工具
- 可迭代对象不能是迭代器,尽管你可以在可迭代对象内部实现
__next__
将其转换为自身的迭代器,但这种做法非常糟糕
要理解以上两点,先明确迭代器的用途,迭代器用来
- 访问一个聚合对象的内容而无需暴露其接口
- 支持对聚合对象的多种遍历
- 为遍历不同的聚合结构提供一个统一的接口(即支持多态迭代)
为了 “支持多种遍历”,必须能从一个可迭代的实例中获取多个独立的迭代器,且各个迭代器能够维护自身内部的状态,因此每次调用可迭代对象内部的
__iter__
方法时都应该创建并返回新的迭代器对象。如果我们强行写在一起,那么上面那种二重循环就无法实现,如下class Sentence: def __init__(self,text): self.words = text.split(' ') self.index = 0 def __iter__(self): return self def __next__(self): try: word = self.words[self.index] except IndexError: raise StopIteration() self.index += 1 return word S = Sentence('one two three') for word1 in S: for word2 in S: print(word1,word2) ''' one two one three '''
注意到,由于这里从头到尾只有一个迭代器实例,迭代到 three 时就终止了,无法实现多重迭代
3. 生成器
- 虽然 2.2 节中说明了可迭代对象不能是自身的迭代器,但我们往往希望实现类似的效果,即每次调用都能返回下一个迭代值,而无需手动创建额外的迭代器对象,某种程度上讲,生成器表现得就像这种 “可迭代对象和迭代器的混合体”
3.1 yield
关键字
-
yield
关键字类似return
,但又有所区别- 执行到
yield
时会返回一个或多个值(元组形式) - 对象会记录此次返回的位置,返回数值之后,挂起,直到下一次执行
__next__
函数,再重新从挂起点接着运行(类似断点的作用)
- 执行到
-
看一段演示程序
def gen_123(): yield 1 yield 2 yield 3
调用一下该函数,发现返回了一个生成器对象(这里用的 jupyter notebook)
查看该对象实现的函数
发现内部实现了__iter__
和__next__
,是个迭代器,连续调用next(g)
以上实验中关注以下几点- 只要 python 函数的定义体中有
yield
关键字,这个函数就是生成器函数,调用生成器函数会返回一个生成器对象 - 生成器内部实现了
__iter__
和__next__
,所以生成器也是迭代器,可以调用__next__
进行迭代 - 每次调用
__next__
迭代时,生成器函数会向前执行到函数体中定义的下一个yield
处,返回生成的值,并在此处挂起等待下一次迭代 - 生成器函数定义体退出时,生成器会抛出
StopIteration
异常
- 只要 python 函数的定义体中有
-
了解上述内容后,再看一个生成器和 for 机制结合使用的示例
根据 for 循环机制,这里首先调用gen_123()
得到一个生成器,然后不断调用next()
生成值,每一次生成都在生成器函数中执行到下一个yield
位置挂起,最后 for 机制捕获StopIteration
异常终止循环,不会报错
3.2 创建生成器对象
- 现在利用生成器实现 2.3 节中可迭代的
Sentence
类,这种实现是符合 python 习惯的
分析一下以上程序class Sentence: def __init__(self,text): self.words = text.split(' ') def __iter__(self): for word in self.words: yield word # 做一个二重迭代 S = Sentence('one two three') for word1 in S: for word2 in S: print(word1,word2) ''' one one one two one three two one two two two three three one three two three three '''
Sentence
内部实现了__iter__
,是一个可迭代对象__iter__
内部有yield
关键字,这是一个生成器函数- 外部做双层 for 循环时,每一层 for 循环最开始都调用
iter()
得到生成器,所以这里有两个独立的生成器分别维护内部的推导状态,可以正确地实现二重迭代
3.3 惰性实现
- 上面实现的
Sentence
类内部都不是惰性实现,因为我们在__init__
函数内部就构建好了所有的文本列表,并将它绑定到self.words
属性上。利用生成器,现在我们可以优雅地完成第 2 节引子部分提出的惰性计算了
3.3.1 惰性实现 Sentence
类
- 实现惰性计算的思路并不难,只要把计算转移到
yield
关键字处即可,下面把 3.2 节改成惰性实现
虽然计算那里实现得不怎么优雅(更好的方式是用正则表达式进行匹配),但确实完成了惰性计算class Sentence: def __init__(self,text): self.text = text def __iter__(self): s = 0 e = self.text.find(' ') while e != -1: yield self.text[s:e] s = e+1 e = self.text.find(' ',s) yield self.text[s:] # 做一个二重迭代 S = Sentence('one two three') for word1 in S: for word2 in S: print(word1,word2) ''' one one one two one three two one two two two three three one three two three three '''
3.3.2 惰性计算自然数
-
自然数是 0,1,2,3… 这样的可列无限长序列,定义一个结构来表示所有的自然数,并要求可以根据任意大小的正整数输入 n 来打印前 n 个自然数
-
序列长度是无限的,我们不可能先直接算出所有自然数存储,只能进行惰性计算。这种要求在 Heskall 中非常容易实现,因为 Heskall 就是基于惰性计算设计的,要定义一个无限大小的序列,只须定义其递归/递推结构即可,在访问序列时 Heskall 会惰性地按需计算,示例如下
-- 定义自然数的递推规则 nextNat :: Integer -> Integer nextNat x = x+1 -- 递推地应用规则,生成无限长的自然数序列 nats :: [Integer] nats = 0 : Prelude.map nextNat nats -- 惰性计算并打印前 20 个值 main :: IO () main = print (take 20 nats) -- [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
-
利用生成器,可以在 python 中实现类似的行为,如下
class NaturalNumber: def __iter__(self): i = 0 while True: yield i i += 1 N = iter(NaturalNumber()) for i in range(20): print(next(N),end=' ') # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
4. 生成器表达式
- 生成器表达式可以理解为列表推导的惰性版本,它不会迫切地构建列表,而是返回一个生成器,按需惰性生成元素 ,可以替代简单的生成器函数
- 先定义一个生成器函数
def gen_123(): print('Start') yield 1 print('Continue') yield 2 print('end')
4.1 惰性执行
- 在列表推导中使用生成器函数
可见列表推导迫切地迭代gen_123()
函数生成的生成器产出所有元素并把它们保存到列表中 - 在生成器表达式中使用生成器函数
使用生成器表达式时,只是把调用gen_123()
获取生成器,但是并不使用,只有在 for 循环迭代时才真正执行(惰性计算)
4.2 节省存储空间
- 使用生成器或迭代器,可以大大缩减列表推导的内存占用
import sys lst = [i for i in range(10000)] # 列表推导 gen = (i for i in range(10000)) # 生成器表达式,gen 此时为一个生成器 it = iter(lst) # 迭代器,由序列生成 print(sys.getsizeof(lst)) # 87624(列表推导) print(sys.getsizeof(gen)) # 88 (生成器表达式) print(sys.getsizeof(it)) # 56 (迭代器)
5. 其他
-
本文仅介绍迭代器、生成器的基础概念,其他相关内容还有
- Python 的标准库和
itertools
模块里面包含了内置的生成器函数,很多时候无需自己写轮子 - 生成器可以当做协程使用
- python 3.3 中出现了
yield from
关键字,可以替换双层 for 迭代的内层循环,同时还会创建通道联系内层的生成器和外层生成器的客户端,主要在协程中使用 - yield 语句可以接受通过生成器 send 方法传入的参数并赋值给一个变量,以动态调整生成器的行为表现
- …
这些内容不再展开,以后有机会再补充
- Python 的标准库和