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

• 写 python 很久了，迭代器和生成器这块一直没深入了解，本文从迭代角度简单捋一下相关概念，不会很全面
• 参考：
  1. python之迭代器和生成器全解–包含实现原理及应用场景
  2. 《流畅的Python》第 14 章

---

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 时就终止了，无法实现多重迭代

3. 生成器

• 虽然 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 
  

4. 生成器表达式

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

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

4.1 惰性执行

1. 在列表推导中使用生成器函数
   
   可见列表推导迫切地迭代 gen_123() 函数生成的生成器产出所有元素并把它们保存到列表中
2. 在生成器表达式中使用生成器函数
   
   使用生成器表达式时，只是把调用 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. 其他

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

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

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