浅析python迭代器及生成器函数

1. 什么是迭代协议？

　　迭代协议主要包括两方面的协议集，一种是迭代器协议，另一种是可迭代协议。对于迭代器协议来说，其要求迭代器对象在能够在迭代环境中一次产生一个结果。对于可迭代协议来说，就是一个对象序列，该序列可以是实际保存的序列，也可以是按照计算需求而产生的虚拟序列

　　在Python中，如何判断一个对象是否可迭代呢？我们可以从collections.abc模块下的Iterable和Iterator得到答案

　　    

　　从图中可以看出， 相比较于Iterator对象，可迭代对象要求实现__iter__（）这一魔法方法即可，而一个迭代器对象不仅需要实现__iter__()方法，还需要实现__next__（）方法，其作用便是能够迭代环境中惰性地返回一次结果。

2.迭代器对象和可迭代对象

　　刚刚我们通过源码分析得出，迭代器对象需要同时拥有__next__()和__iter__()方法，而一个可迭代对象要求实现__iter__()方法。

　　那么在Python的数据类型中，那些类型对象是可迭代的呢？ 一方面我们可以通过查看所属类型的源码来得出答案，另一方面也可以通过isinstance方法来得知。

　　

　　在Python的数据类型中， tuple、set、dict、string、list均是可迭代类型。

3.自定义迭代器

　　在自定义迭代器之前，我们先来看一段代码

# coding:utf-8
from collections.abc import Iterator, Iterable

class MyIterator():

    def __init__(self, _list: list):
        self._list = _list
        self.eq = 0

    def __iter__(self):
        return self

    def __next__(self):
        """迭代输出，可能造成eq超出_list的最大下标"""
        try:
            cur = self._list[self.eq]
        except IndexError:
            # 超出范围抛出StopIteration异常
            raise StopIteration
        else:
            self.eq += 1
            return cur

class _Class(object):

    def __init__(self, members: list):
        self.members = members

    def __iter__(self):
        """实现了可迭代协议，就是一个可迭代对象"""
        return MyIterator(self.members)

def main():
    """测试"""
    students = ["stu[{0}]".format(num) for num in range(1, 11)]
    _class = _Class(students)
    # 将_class转化为迭代器对象
    _class_itor = iter(_class)
    print("_class_itor对象是MyIterator的实例：",isinstance(_class_itor, MyIterator))
    while 1:
        try:
            cur = next(_class_itor)
            print(cur)
        except StopIteration:
            print("迭代完成")
            break

if __name__ == '__main__':
    main()

　　输出为：

　　

　　在以上程序中，_Class类拥有__iter__方法便实现了可迭代协议，其对象就是可迭代对象，但是奇怪的是为什么执行iter方法得到的_class_itor对象是MyIterator的实例呢？

　　我们继续改写代码，使得__iter__返回其自身对象（_Class，只是一个可迭代对象，没有实现__next__方法）,看一下效果：

class _Class(object):

    def __init__(self, members: list):
        self.members = members

    def __iter__(self):
        """实现了可迭代协议，就是一个可迭代对象"""
        # return MyIterator(self.members)
        return self

def main():
    """测试"""
    students = ["stu[{0}]".format(num) for num in range(1, 11)]
    _class = _Class(students)
    # 将_class转化为迭代器对象
    _class_itor = iter(_class)
    print("_class_itor对象是MyIterator的实例：",isinstance(_class_itor, MyIterator))
    while 1:
        try:
            cur = next(_class_itor)
            print(cur)
        except StopIteration:
            print("迭代完成")
            break

if __name__ == '__main__':
    main()

　　运行输出：

　　

　　意料之中，iter函数要求接收的参数对象必须是一个迭代器类型，即实现了__next__方法，在上述代码中，_Class类型只属于可迭代类型，并没有实现__next__方法，所以报错了。

　　那么按照上述说法，我们继续改写程序，让_Class的__iter__方法返回一个迭代器对象呢？

　　

class _Class(object):

    def __init__(self, members: list):
        self.members = members

    def __iter__(self):
        """实现了可迭代协议，就是一个可迭代对象"""
        # return MyIterator(self.members)
        return iter(["stu[{0}]".format(num) for num in range(1, 11)])

def main():
    """测试"""
    students = ["stu[{0}]".format(num) for num in range(1, 11)]
    _class = _Class(students)
    # 将_class转化为迭代器对象
    _class_itor = iter(_class)
    print("_class_itor对象是MyIterator的实例：",isinstance(_class_itor, MyIterator))
    while 1:
        try:
            cur = next(_class_itor)
            print(cur)
        except StopIteration:
            print("迭代完成")
            break

if __name__ == '__main__':
    main()

　　运行输出：

　　

　　由此，我们得出结论：迭代器类型需要实现__next__方法和__iter__方法，并且特别注意的是__iter__方法的返回值需要是Iterator类型， __next__方法只是暂存了迭代器对象在当次迭代环境下的当次结果。

4. 生成器函数

　　在分析生成器函数之前，先来一段代码

import builtins
def gen_func():
    yield 1
    yield 2
    yield 3
    yield 4
    yield 5

def func():
    return 1

if __name__ == '__main__':
    gen = gen_func()
    print(gen)
    print(hasattr(gen, "__next__"))
    print(hasattr(gen, "__iter__"))
    fun = func()
    print(fun)

　　运行结果：

　　

　　可以看出，gen_func()函数多次使用yield关键字来惰性地抛出数值，但gen不再是一个int类型，而是一个generator对象， 这便是一个生成器函数（yield作为返回关键字而不采用return）。除此之外，还可以发现generator对象实现了__iter__和__next__方法，也就是说生成器函数对象属于迭代器类型，那么生成器函数对象肯定能够使用迭代语句进行惰性地获取结果。

　　

5.用生成器函数惰性实现斐波拉契序列

　　1. 采用普通形式（递归地方式，缺点是不能看到完整的数列）

def fib(index):
    """1, 1, 2, 3, 5, 8......."""
    if index<=2:
        return 1
    return fib(index-1) + fib(index-2)

if __name__ == '__main__':
    print(fib(8))  #21

　　

　　2. 改进代码，使用列表来存储（采用循环的方式， 缺点是列表的存储空间是有上限的，十分消耗内存）

def fib2(index):
    """1, 1, 2, 3, 5, 8......."""
    res = list()
    cur_index, ppre, pre = 0, 0, 1
    while cur_index<index:
        res.append(pre)
        ppre, pre = pre, pre+ppre
        cur_index += 1
    return res

if __name__ == '__main__':
    print(fib2(8))      # [1, 1, 2, 3, 5, 8, 13, 21]

　　

　　3. 生成器函数实现（有效解决内存问题，即用即取，惰性操作）

def fib3(index):
    cur_index, ppre, pre = 0, 0, 1
    while cur_index<index:
        yield pre
        ppre, pre = pre, ppre+pre
        cur_index += 1

if __name__ == '__main__':
    for value in fib3(8):
        print(value)

　　结果：

　　

6. 使用生成器函数实现大文件（百GB级，且数据未分行）的读取

　　对于大文件的读取，首先考虑的是避免将结果集一次性加载到内存，如果待读取文件是格式按照预先设定规则来进行换行的，如下：

　　

　　这样的文件直接采用迭代方式读取(for line in file)即可，但如果该文件如下且容量为1TB的该如何逐条读取SQL语句呢？

　　

　　这时候yield关键字就派上用场了。

　　我们可以做如下思考：

　　1）文件句柄的read方法，能够接受一个参数作为输出流的缓冲区大小。

　　2）循环读取一定容量的数据进行处理，并在每次迭代环境下将一条完整的insert语句抛出。

def yieldLines(file, buffer_size,  flag):
    buf = ""
    while True:
        while flag in buf:
            pos = buf.index(flag)
            yield buf[:pos]
            buf = buf[pos+len(flag):]
        chunk = file.read(buffer_size)
        # 读取结束
        if not chunk:
            yield buf
            break
        buf += chunk

if __name__ == '__main__':
    with open('./data_insert.txt', 'r') as f:
        for line in yieldLines(f, 1024, "|||"):
            print(line)

　　运行结果：

　　

7. 深度分析生成器函数

　　在操作系统上有着进程（线程）的概念，在并发（并发是指在一段时间范围内，有多个线程/进程交替被CPU调度；并行是指在一个时间点上，有多个线程/进程被CPU调度，利用的CPU的多核心）执行的时候，程序遇IO操作，为了性能，常见的方式是采用异步非阻塞，但是当IO操作完成，进程由阻塞态转为就绪态时，依据于PCB(进程控制块)，其进程能够记住运行上下文，达到继续从阻塞位置之后执行程序代码的效果。

　　对于生成器函数而言，其内部也维持了这样一个运行状态的记录，下面我们来对其进行分析

import dis

def gen_func():
    a = 1
    yield a
    b = 2
    yield b
    c =3
    yield c

if __name__ == '__main__':
    gen = gen_func()
    print(dis.dis(gen))

　　运行结果如下，显示的是该生成器函数的字节码形式：

　　

　　乍一看是不是很像汇编语言的指令，的确也类似这样，Python模块被编译成字节码文件之后才交由python解释器来解释执行，这样的指令就被赋予了新的含义，例如：

　　LOAD_FAST一般加载局部变量的值，也就是读取值，用于计算或者函数调用传参等。

　　STORE_FAST一般用于保存值到局部变量。

　　LOAD_GLOBAL用来加载全局变量，包括指定函数名，类名，模块名等全局符号。

　　其他指令可以查看这篇博文来获取

　　

　　有了以上字节码形式，我们可以清楚的了解到函数被解释的细致流程，生成器函数运行状态上下文的记录便依据上图，下面我们来分析一下：

def gen_func():
    a = 1
    yield a
    b = 2
    yield b
    c =3
    yield c

if __name__ == '__main__':
    gen = gen_func()
    # print(dis.dis(gen))
    for _ in gen:
        print(gen.gi_frame.f_lasti)
        print(gen.gi_frame.f_locals)

　　运行结果如下：

　　

　　通过比较上图两张截图可以看出gi_frame.f_lasti记录了每次python解释器执行YIELD_VALUE指令时的状态编码，来确定生成器函数的运行上下文。