Python 迭代器和生成器

Question

可迭代对象

在 Python 中，很多对象都是可以通过 for 语句来直接遍历的，例如 string、list、dict、set 等等，这些对象都可以被称为可迭代对象

迭代器

• 从使用看，凡是可以支持 for i in object: 的方式逐步访问对象元素的，即是迭代器
• 从内部看：迭代器对象要求支持迭代器协议的对象，在 Python 中，支持迭代器协议就是实现对象的 __iter__() 和 __next__ 方法。其中 __iter__() 方法返回迭代器对象本身； __next()__ (py3) next() (py2) 方法返回容器的下一个元素，在结尾时引发 StopIteration 异常。

iter () 和__next__() 方法

这两个方法是迭代器最基本的方法，一个用来获得迭代器对象，一个用来获取容器中的下一个元素。对于可迭代对象，可以使用内建函数 iter() 来获取它的迭代器对象

#!/usr/bin/env python3
l = [1, 2, 3]
it = iter(l)
print(next(it))
print(next(it))

代码例子中，通过 iter() 方法获得了 list 的迭代器对象，然后就可以通过 __next__() (python3) next() (python2) 方法来访问 list 中的元素了。当容器中没有可访问的元素后，next() 方法将会抛出一个 StopIteration 异常终止迭代器

自定义迭代器

知道迭代器协议之后，就可以自定义迭代器了。实现了一个 MyRange 的类型，这个类型中实现了 __iter__() 方法，通过这个方法返回对象本身作为迭代器对象；同时，实现了 __next__() 方法用来获取容器中的下一个元素，当没有可访问元素后，就抛出 StopIteration 异常。

#!/usr/bin/env python3
class MyRange:
    def __init__(self, n):
        self.idx = 0
        self.n = n

    def __iter__(self):
        return self

    # py2 可以用 next() 方法， py3 要用 __next__() 方法
    def __next__(self):
        if self.idx < self.n:
            val = self.idx
            self.idx += 1
            return val
        else:
            raise StopIteration()

# 这个自定义类型跟内建函数 xrange(py3)range(py3) 很类似，看一下运行结果
myRange = MyRange(3)
for i in myRange:
    print(i)

迭代器和可迭代对象

在上面的例子中，myRange 这个对象就是一个可迭代对象，同时它本身也是一个迭代器。看下面的代码，对于一个可迭代对象，如果它本身又是一个迭代器，就会有下面的问题，就没有办法支持多次迭代

myRange = MyRange(3)

print(myRange is iter(myRange))  # True 对象本身既是迭代器又是可迭代对象
print([i for i in myRange])      # [0, 1, 2]
print([i for i in myRange])      # [] 多次从开始迭代可迭代对象 初始值不一样

为了解决上面的问题，可以分别定义可迭代对象和迭代器对象；然后可迭代类型对象的 __iter__() 方法可以获得一个迭代器类型的对象

class Zrange:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return ZrangeIterator(self.n)

class ZrangeIterator:
    def __init__(self, n):
        self.i = 0
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.i < self.n:
            i = self.i
            self.i += 1
            return i
        else:
            raise StopIteration()

myZrange = Zrange(3)

print(myZrange is iter(myZrange))   # False 可迭代对象和迭代器对象不是同一对象 myZrange 是 myZrange 对象，而 iter(myZrange) 是 ZrangeIterator 对象
print([i for i in myZrange])        # [0, 1, 2]
print([i for i in myZrange])        # [0, 1, 2]

其实，通过下面代码可以看出，list 类型也是按照上面的方式，list 本身是一个可迭代对象，通过 iter() 方法可以获得 list 的迭代器

l = [1, 2, 3]

print(l is iter(l))
print('__iter__' in dir(l))
print('__iter__' in dir(iter(l)))
print('__next__' in dir(iter(l)))

生成器

在 Python 中，使用生成器可以很方便的支持迭代器协议。生成器通过生成器函数产生，生成器函数可以通过常规的 def 语句来定义，但是不用 return 返回，而是用 yield 一次返回一个结果，在每个结果之间挂起和继续它们的状态，来自动实现迭代协议。也就是说， yield 是一个语法糖 ，内部实现支持了迭代器协议，同时 yield 内部是一个状态机，维护着挂起和继续的状态

def zrange(n):
    i = 0
    while i < n:
        yield i
        i += 1

zrange = zrange(10)
print(zrange)
print([i for i in zrange])

在这个例子中，定义了一个生成器函数，函数返回一个生成器对象，然后就可以通过 for 语句进行迭代访问了。其实，生成器函数返回生成器的迭代器( 生成器是一个特殊的迭代器 )。 生成器的迭代器 这个术语通常被称作"生成器"。要注意的是生成器就是一类 特殊的迭代器 。作为一个迭代器，生成器必须要定义一些方法，其中一个就是 __next__() 。如同迭代器一样，我们可以使用 __next()__ 函数来获取下一个值

生成器执行流程

从上面的例子也可以看到，生成器函数跟普通的函数是有很大差别的。结合上面的例子我们加入一些打印信息，进一步看看生成器的执行流程

def zrange(n):
    print('begin do zrange')
    i = 0
    while i < n:
        print('before yield')
        yield i
        print('after yield')
        i += 1
    print('finish do zrange')

zrange = zrange(3)
print('-' * 10)
print(zrange.__next__())

print('-' * 10)
print(zrange.__next__())

print('-' * 10)
print(zrange.__next__())

print('-' * 10)
print(zrange.__next__())

从运行结果可以看到：

• 当调用生成器函数的时候，函数只是返回了一个生成器对象，并没有执行。
• 当 __next__() 方法第一次被调用的时候，生成器函数才开始执行，执行到 yield 语句处停止
• __next__() 方法的返回值就是 yield 语句处的参数（yielded value）
• 当继续调用 __next__() 方法的时候，函数将接着上一次停止的 yield 语句处继续执行，并到下一个 yield 处停止；如果后面没有 yield 就抛出 StopIteration 异常（和迭代器和行为一样)

生成器表达式

在开始介绍生成器表达式之前，先看看我们比较熟悉的列表解析(List comprehensions)，列表解析一般都是下面的形式

[expr for iter_var in iterable if cond_expr]

迭代 iterable 里所有内容，每一次迭代后，把 iterable 里满足 cond_expr 条件的内容放到 iter_var 中，再在表达式 expr 中应该 iter_var 的内容，最后用表达式的计算值生成一个列表

生成器表达式是在 python2.4 中引入的，当序列过长， 而每次只需要获取一个元素时，应当考虑使用生成器表达式而不是列表解析。生成器表达式的语法和列表解析一样，只不过生成器表达式是被() 括起来的，而不是[]，如下

(expr for iter_var in iterable if cond_expr)

生成器表达式并不是创建一个列表，而是返回一个生成器，这个生成器在每次计算出一个条目后，把这个条目 yield 出来。 生成器表达式使用了"惰性计算"（ lazy evaluation ），只有在检索时才被赋值（evaluated），所以在列表比较长的情况下使用内存上更有效，如下：

gen = (i for i in range(50) if i % 2 == 0)
print(gen)
print([i for i in gen])

生成器表达式产生的生成器，它自身是一个可迭代对象，同时也是迭代器本身，如下：

gen = (i for i in range(50) if i % 2 == 0)
print('__iter__' in dir(gen))          # True
print('__next__' in dir(gen))          # True
print(gen is iter(gen))                # True
print(sum(gen))                        # 600
print([i for i in gen])                # []  生成器和迭代器一样，当轮询完了之后就会返回空值

生成器的 send() 和 close() 方法

生成器中还有两个很重要的方法： send() 和 close()

send(value) : 从前面了解到， next() 方法可以恢复生成器状态并继续执行（生成器是一个特殊的迭代器，所以也是支持 __iter__ 以及 __next__ 方法的)，其实 send() 是除 next() 外另一个 恢复 生成器的方法，参照 Python 生成器 generator 之 next 和 send 运行流程

Python2.5 中，yield 语句变成了 yield 表达式，也就是说 yield 可以有一个值，而这个值就是 send() 方法的参数，所以 send(None) 和 __next__() 是等效的，且首次调用生成器一定要用 send(None) 或者 __next__() ，因为第一次只执行到 yield 表达式，没有执行到赋值操作。同样，next() 和 send() 的返回值都是 yield 语句处的参数（yielded value）

关于 send() 方法需要注意的是：调用 send 传入非 None 值前，生成器必须处于挂起状态，否则将抛出异常。也就是说，第一次调用时，要使用 next() 语句或 send(None)，因为没有 yield 语句来接收这个值

close() : 这个方法用于 关闭 生成器，对关闭的生成器后再次调用 next 或 send 将抛出 StopIteration 异常

def zrange(n):
    i = 0
    while i < n:
        val = yield i
        print('val is: ', val)
        i += 1

z = zrange(5)
print(z.__next__())
print('-' * 10)
print(z.send('hello'))
print('-' * 10)
print(z.__next__())
print('-' * 10)
z.close()

总结

• 通过实现迭代器协议对应的 __iter__() 和 __next__() 方法，可以自定义迭代器类型。对于可迭代对象，for 语句可以通过 __iter__() 方法获取迭代器，并且通过 __next__() 方法获得容器的下一个元素
• 像列表这种序列类型的对象，可迭代对象和迭代器对象是相互独立存在的，在迭代的过程中各个迭代器相互独立；但是，有的可迭代对象本身又是迭代器对象，那么迭代器就没法独立使用
• itertools 模块提供了一系列迭代器，能够帮助用户轻松地使用排列、组合、笛卡尔积或其他组合结构
• 生成器是一种 特殊的迭代器 ，内部支持了生成器协议，不需要明确定义 __iter__() 和 __next__() 方法
• 生成器通过 生成器函数 产生，生成器函数可以通过常规的 def 语句来定义，但是不用 return 返回，而是用 yield 一次返回一个结果

FAQ

• 对象如果是迭代器，又是可迭代对象，多次迭代的时候就会产生问题。因为一个迭代器的值迭代完了之后就不能回去了，对同一个迭代器进行多次迭代的时候会导致初始值不同。如果想要实现多次迭代时初始值相同，可以使用可迭代对象调用迭代器，每次调用可迭代对象完成迭代器的初始化，详情 迭代器和可迭代对象

• 先看这个： SO-What does the “yield” keyword do
• Python 迭代器和生成器