Python 迭代器 生成器

迭代器（Iterator）

可以直接作用于for循环的对象，统称为可迭代对象：Iterable。
可以被next()函数调用并不断返回下一个值的对象，称为迭代器：Iterator。

Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等。

与一般的序列类型(list, tuple等)有什么区别：
它一次只返回一个数据项，占用更少的内存。
但它需要记住当前的状态，以便返回下一数据项。它是一个有着next()方法的对象。
而序列类型则保存了所有的数据项，它们的访问是通过索引进行的。

对于原生支持随机访问的数据结构（如tuple、list），迭代器和经典for循环的索引访问相比并无优势，反而丢失了索引值（可以使用内建函数enumerate()找回这个索引值）。

迭代器有两个基本的方法

next方法：返回迭代器的下一个元素
__iter__方法：返回迭代器对象本身

迭代器：仅是一容器对象，它实现了迭代器协议。

下面用生成斐波那契数列为例子，说明为何用迭代器。
def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        print b 
        a, b = b, a + b 
        n = n + 1
直接在函数fab(max)中用print打印会导致函数的可复用性变差，因为fab返回None。其他函数无法获得fab函数返回的数列。
def fab(max): 
    L = []
    n, a, b = 0, 0, 1 
    while n < max: 
        L.append(b) 
        a, b = b, a + b 
        n = n + 1
    return L
满足了可复用性的需求，但是占用了内存空间，最好不要。
class Fab(object):
    def __init__(self, max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def next(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r

        raise StopIteration

>>> for key in Fabs(5):
    print key
      
1
1
2
3
5
Fabs 类通过 next() 不断返回数列的下一个数，内存占用始终为常数

生成器

带有 yield 的函数在 Python 中被称之为 generator（生成器），几个例子说明下（还是用生成斐波那契数列说明）
可以看出代码3远没有代码1简洁，生成器（yield）既可以保持代码1的简洁性，又可以保持代码3的效果

def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b

        n = n + 1

>>> for n in fab(5):
    print n
     
1
1
2
3
5
yield 的作用就是把一个函数变成一个 generator。
带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。
调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！
在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

文件读取

def read_file(fpath): 
    BLOCK_SIZE = 1024 
    with open(fpath, 'rb') as f: 
        while True: 
            block = f.read(BLOCK_SIZE) 
            if block: 
                yield block 
            else: 
                return
如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。
好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取。

类型判断

判断一个函数是否是一个特殊的 generator 函数
 >>> from inspect import isgeneratorfunction 
 >>> isgeneratorfunction(fab) 
 True
要注意区分 fab 和 fab(5)，fab 是一个 generator function，而 fab(5) 是调用 fab 返回的一个 generator，好比类的定义和类的实例的区别：
 >>> import types 
 >>> isinstance(fab, types.GeneratorType) 
 False 
 >>> isinstance(fab(5), types.GeneratorType) 
 True
fab 是无法迭代的，而 fab(5) 是可迭代的：
 >>> from collections import Iterable 
 >>> isinstance(fab, Iterable) 
 False 
 >>> isinstance(fab(5), Iterable) 

 True

使用isinstance()判断一个对象是否是Iterable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True>>> isinstance({}, Iterable)
True>>> isinstance('abc', Iterable)
True>>> isinstance((x for x in range(10)), Iterable)
True>>> isinstance(100, Iterable)

False

使用isinstance()判断一个对象是否是Iterator对象：
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator) #是(x for x in range(10))不是[x for x in range(10)]
True>>> isinstance([], Iterator)
False>>> isinstance({}, Iterator)
False>>> isinstance('abc', Iterator)

False