Python入门笔记8 - 可迭代对象、迭代器、生成器

• 写 python 很久了，迭代器和生成器这块一直没深入了解，本文从迭代角度简单捋一下相关概念，不会很全面
• 参考：

1. ​​python之迭代器和生成器全解–包含实现原理及应用场景​​
2. 《流畅的Python》第 14 章

文章目录

• ​​1. 可迭代对象​​

• ​​1.1 基础概念​​
• ​​1.2 基于 `__getitem__` 生成可迭代对象​​

• ​​1.2.1 只实现 `__getitem__`​​
• ​​1.2.2 同时实现 `__getitem__` 和 `__iter__`​​

• ​​2. 迭代器​​

• ​​2.1 迭代器接口​​
• ​​2.2 从可迭代对象生成迭代器（for 循环的本质）​​
• ​​2.3 创建标准的迭代器​​

• ​​3. 生成器​​

• ​​3.1 `yield` 关键字​​
• ​​3.2 创建生成器对象​​
• ​​3.3 惰性实现​​

• ​​3.3.1 惰性实现 `Sentence` 类​​
• ​​3.3.2 惰性计算自然数​​

• ​​4. 生成器表达式​​

• ​​4.1 惰性执行​​
• ​​4.2 节省存储空间​​

• ​​5. 其他​​

1. 可迭代对象

1.1 基础概念

• ​​可迭代对象​​：python 中可以通过 ​​for...in...​​ 语法从中迭代地依次返回数据的对象称为可迭代对象，python 内置的列表、元组、字典、集合、字符串等类型的对象都是可迭代对象



• 当 python 需要迭代对象 x 时，会调用内置方法 ​​iter(x)​​，该方法返回 x 的迭代器对象，这会按照以下流程进行

1. 检查对象是否是实现了 ​​__iter__​​ 方法，如果实现了就调用它，这会返回一个迭代器
2. 如果没有实现 ​​__iter__​​​，则检查对象是否实现了 ​​__getitem__​​ 方法，如果实现了就创建一个迭代器，尝试按顺序（从索引 0 开始）获取元素
3. 如果尝试失败，抛出异常 ​​TypeError​​​，通常会提示 ​​x object is not iterable​​

根据鸭子类型的思想，只要实现了 ​​__iter__​​ 方法，或者实现了 ​​__getitem__​​ 方法且其参数是从 0 开始的整型数，就可以认为对象是可迭代的

• 早期的 python 中没有迭代器的概念，迭代工作主要靠序列完成

准确说是靠序列中的 ​​__getitem__​​​ 方法，该方法允许按照下标索引，如 ​​x[index]​​

• 举例来说，​​for​​ 循环中的 ​​range​​ 函数过去会直接展开成列表，这很可能造成严重的内存问题。随着 python 引入迭代器的概念，现在的迭代场景几乎都改成由迭代器或生成器支持的了，包括

1. for 循环
2. 构建和扩展集合类型
3. 逐行遍历文本文件
4. 列表推导、字典推导、集合推导
5. 元组拆包
6. 调用函数时，用 ​​*​​ 拆包实参

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 迭代器接口

• 标准的迭代器接口要实现两个方法

1. ​​__iter__​​​：返回 ​​self​​（注意自己本身就是一个迭代器了），以便在应该使用可迭代对象的地方使用迭代器，比如 for 循环中。执行 ​​iter(x)​​ 会调用对象 ​​x​​ 所属类别的该方法得到一个迭代器对象
2. ​​__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 机制其实做了以下几件事

  1. 根据 ​​ABC​​ 所属 String 类的 ​​__iter__​​ 方法得到其对应的迭代器
  2. 不断在迭代器上调用 ​​__next__​​ 方法，迭代地获取字符打印
  3. 遍历完成后撤掉迭代器对象

  可以使用 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
  '''

• 需要注意的是：不要混淆迭代器和可迭代对象

  1. 迭代器是为了迭代可迭代对象而创建的工具
  2. 可迭代对象不能是迭代器，尽管你可以在可迭代对象内部实现 ​​__next__​​ 将其转换为自身的迭代器，但这种做法非常糟糕

  要理解以上两点，先明确迭代器的用途，迭代器用来

  1. 访问一个聚合对象的内容而无需暴露其接口
  2. 支持对聚合对象的多种遍历
  3. 为遍历不同的聚合结构提供一个统一的接口（即支持多态迭代）

  为了 “支持多种遍历”，必须能从一个可迭代的实例中获取多个独立的迭代器，且各个迭代器能够维护自身内部的状态，因此每次调用可迭代对象内部的 ​​__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 时就终止了，无法实现多重迭代

• 虽然 2.2 节中说明了可迭代对象不能是自身的迭代器，但我们往往希望实现类似的效果，即每次调用都能返回下一个迭代值，而无需手动创建额外的迭代器对象，某种程度上讲，生成器表现得就像这种 “可迭代对象和迭代器的混合体”

3.1 ​​yield​​ 关键字

• ​​yield​​ 关键字类似 ​​return​​，但又有所区别

  1. 执行到 ​​yield​​ 时会返回一个或多个值（元组形式）
  2. 对象会记录此次返回的位置，返回数值之后，挂起，直到下一次执行 ​​__next__​​ 函数，再重新从挂起点接着运行（类似断点的作用）

• 看一段演示程序

  def gen_123():
      yield 1
      yield 2
      yield 3

• 调用一下该函数，发现返回了一个生成器对象（这里用的 jupyter notebook）



• 查看该对象实现的函数



• 发现内部实现了 ​​__iter__​​ 和 ​​__next__​​，是个迭代器，连续调用 ​​next(g)​​



• 以上实验中关注以下几点
1. 只要 python 函数的定义体中有 ​​yield​​ 关键字，这个函数就是生成器函数，调用生成器函数会返回一个生成器对象
2. 生成器内部实现了 ​​__iter__​​ 和 ​​__next__​​，所以生成器也是迭代器，可以调用 ​​__next__​​ 进行迭代
3. 每次调用 ​​__next__​​ 迭代时，生成器函数会向前执行到函数体中定义的下一个 ​​yield​​ 处，返回生成的值，并在此处挂起等待下一次迭代
4. 生成器函数定义体退出时，生成器会抛出 ​​StopIteration​​ 异常
• 了解上述内容后，再看一个生成器和 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
'''

• 分析一下以上程序
1. ​​Sentence​​ 内部实现了 ​​__iter__​​，是一个可迭代对象
2. ​​__iter__​​ 内部有 ​​yield​​ 关键字，这是一个生成器函数
3. 外部做双层 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

• 生成器表达式可以理解为列表推导的惰性版本，它不会迫切地构建列表，而是返回一个生成器，按需惰性生成元素 ，可以替代简单的生成器函数
• 先定义一个生成器函数

def gen_123():
    print('Start')
    yield 1
    print('Continue')
    yield 2
    print('end')

4.1 惰性执行

2. 在列表推导中使用生成器函数



3. 可见列表推导迫切地迭代 ​​gen_123()​​ 函数生成的生成器产出所有元素并把它们保存到列表中
5. 在生成器表达式中使用生成器函数



6. 使用生成器表达式时，只是把调用 ​​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 （迭代器）

• 本文仅介绍迭代器、生成器的基础概念，其他相关内容还有

  1. Python 的标准库和 ​​itertools​​ 模块里面包含了内置的生成器函数，很多时候无需自己写轮子
  2. 生成器可以当做协程使用
  3. python 3.3 中出现了 ​​yield from​​ 关键字，可以替换双层 for 迭代的内层循环，同时还会创建通道联系内层的生成器和外层生成器的客户端，主要在协程中使用
  4. yield 语句可以接受通过生成器 send 方法传入的参数并赋值给一个变量，以动态调整生成器的行为表现
  5. …

  这些内容不再展开，以后有机会再补充