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