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指令时的状态编码，来确定生成器函数的运行上下文。