python的迭代协议
引言
迭代器是访问集合内部元素的一种方式，一般用来遍历数据。
迭代器和用下标索引访问的方式不一样，迭代器是不能直接返回值的。
迭代器提供了一种惰性访问数据的方式，需要的时候才产生数据。
可迭代类型都实现了迭代协议，实际上就是__iter__()这个魔法函数。
可迭代类型和迭代器
前面讲过，collections.abc模块中定义了很多内置的抽象基类，现在我们重点关注其中的两个：Iterable 和 Iterator
Iterable
里面定义了一个抽象方法，__iter__()，也就是说某个类只要实现了这个魔法函数，它就是可迭代的类型
Iterator
首先，Iterator继承了Iterable，在它的基础上，又增加了一个抽象方法：__next__()，它是用来让迭代器获取下一个元素。
小结
可迭代类型和迭代器并不一样，前者只需要实现__iter__()函数，而对后者而言，__next__()才是它的核心。
比如list类型，它是一个可迭代类型，但并不是一个迭代器。
a = [1, 2, 3]
print(isinstance(a, Iterable), isinstance(a, Iterator))
# result:
# True False
补充
在魔法函数那一小节，我们讲过这样一个例子：
class Language(object):
def __init__(self, language_list):
self.lans = language_list
def __getitem__(self, item):
return self.lans[item]
language = Language(["Python", "C", "Lisp"])
for lan in language:
print(lan)
# result:
# Python
# C
# Lisp
在Language这个类中，我们定义的是__getitem__这个魔法函数，然后对这个类产生的实例我们可以使用for来遍历元素了。也就是说它成为了一个可迭代类型，但它并没有实现刚才我们讨论的__iter__()函数。
这是因为，在Python内部，很多地方做了兼容处理，当我们是用for进行迭代遍历，解释器首先会寻找__iter__()函数，如果没有，它就会退一步去寻找__getitem__()，这个是序列类型中会实现的一个魔法函数，只要它接收从 0 开始的整数为参数，这个对象也是会被当做可迭代类型的。
实际上，仅仅满足了可迭代类型还不够，真正能进行迭代取值的是迭代器。通过iter()函数，我们可以返回一个可迭代对象的迭代器，有了它才能进行迭代取值。
class Language(object):
def __init__(self, language_list):
self.lans = language_list
def __getitem__(self, item):
return self.lans[item]
language = Language(["Python", "C", "Lisp"])
my_iterator = iter(language)
print(my_iterator)
# result:
#
如果我们不实现__iter__()或__getitem__()，获取迭代器的过中会出错
class Language(object):
def __init__(self, language_list):
self.lans = language_list
language = Language(["Python", "C", "Lisp"])
my_iterator = iter(language)
print(my_iterator)
# result:
# TypeError: 'Language' object is not iterable
有了迭代器，迭代取值需要另外一个函数next()，每调用一次，就会返回一个值，直到抛出一个迭代结束的异常。
class Language(object):
def __init__(self, language_list):
self.lans = language_list
def __getitem__(self, item):
return self.lans[item]
language = Language(["Python", "C", "Lisp"])
my_iterator = iter(language)
print(next(my_iterator))
print(next(my_iterator))
print(next(my_iterator))
print(next(my_iterator))
# result:
# Python
# C
# Lisp
# StopIteration
上面的结果已经很接近直接使用for进行迭代了，但是，依赖__getitem__()函数，底层还是隐藏了很多细节，如果我们想纯粹地通过__iter__()来实现迭代过程，要怎么做呢？
__iter__()用来返回一个迭代器，通过这个迭代器来迭代取值，对应显示调用iter()的逻辑。
__next__()用来让迭代器取下一个值，对应显示调用next()的逻辑。
使用for的时候，这两个魔法函数会被自动调用，完成迭代取值过程。
from collections.abc import Iterator
class MyIterator(Iterator):
def __init__(self, data_list):
self.iter_list = data_list
self.index = 0
def __next__(self):
# 这里是通过记录索引，单次取值达到迭代目的
# 更好的方式是通过生成器来进行迭代取值
try:
data = self.iter_list[self.index]
except IndexError:
raise StopIteration
self.index += 1
return data
class Language(object):
def __init__(self, language_list):
self.lans = language_list
def __iter__(self):
return MyIterator(self.lans)
language = Language(["Python", "C", "Lisp"])
for lan in language:
print(lan)
# result:
# Python
# C
# Lisp
生成器函数使用
引言
函数里面只要存在yield关键字，它就是生成器函数
生成器是惰性计算的一个关键
使用案例
def gen_func():
yield "MetaTian"
def func():
return "MetaTian"
gen, res = gen_func(), func()
print(gen)
print(res)
# result:
#
# MetaTian
for val in gen：
print(val)
# result:
# MetaTian
第一个函数返回的是一个生成器对象，它是一个可迭代类型，因此，可以通过for进行访问。
def gen_func():
yield 1
yield 2
yield 3
gen = gen_func()
for val in gen:
print(val)
# result:
# 1
# 2
# 3
生成器的原理
Python中函数工作原理
对于编译型语言，函数的调用会维持一个函数调用栈，某个函数执行完成后，它就会被出栈处理，也就是说，函数执行后，它的生命周期就结束了。
对于Python这样的解释型语言，函数的调用也要依赖栈结构，但是，函数对象是存放在堆内存中的，也就意味着，一个函数被调用执行了，它还在那儿。
什么是堆内存和栈内存？
解释器用一个叫做PyEval_EvalFrameEx的C函数来执行Python程序。对于一个Python中的函数，解释器接受一个栈帧（stack frame）对象，并在这个栈帧的上下文中执行Python字节码，完成函数调用。在字节码执行中，如果遇到了要调用其他函数的指令，解释器会创建一个新的栈帧用来执行新调用的函数。
生成器+函数
def gen_func():
yield 1
name = "MetaTian"
yield 2
return "done"
在Python将函数编译为字节码时，如果遇到yield关键字，它就知道这是一个生成器函数，内部会做一个标记。当我们调用这个函数的时候，解释器看到这个标记后就会创建一个生成器，而不是去运行它，后续函数的执行交给生成器控制。
这个生成器内部有两个东西，一是对栈帧的引用，二是函数字节码的引用。栈帧中有一个指针，指向最近执行的那条指令，因为执行到和yield有关的字节码后，函数会停止执行，相当于打了个断点，同时将yield后面的值返回。通过next()，可以让函数继续执行（因为生成器也是迭代器），直到遇到下一个yield。
生成器对象也是分配在堆内存中的，也就是说，只要我们在程序运行的任何地方拿到了这个对象，都可以用它来控制函数的执行。这也是后面携程的一个理论基础。
重构自己的可迭代类型
引言
前面将Language这个类，构建成为了我们自定义的一个可迭代类型。
生成器也是迭代器，通过使用生成器，可以更简洁地达成目的。
from collections.abc import Iterator
def gen_func():
yield "MetaTian"
gen = gen_func()
print(isinstance(gen, Iterator))
# result:
# True
使用案例
class Language(object):
def __init__(self, language_list):
self.lans = language_list
def __iter__(self):
i = 0
try:
while True:
val = self.lans[i]
yield val
i += 1
except IndexError:
return
language = Language(["Python", "C", "Lisp"])
for lan in language:
print(lan)
# result:
# Python
# C
# Lisp
总结
这里再来回顾一下前面讲过的内容，使用for遍历的时候，首先会看作用对象是否为一个可迭代类型，如果是，那么会隐式调用__iter__()，得到一个迭代器对象，有了它，再隐式调用__next__()来不断获取下一个元素，直到
遇到一个停止迭代的异常。我们也可以通过内置的两个函数iter()和next()来人工干预迭代的过程。
在Language类中，__iter__()内部加入了一个生成器的逻辑，结合前面的生成器函数，可以知道，遇到yield语句后，会产生一个生成器对象，由它来控制这个函数的后续执行。
因为生成器也是迭代器，所以__next__()的逻辑对它同样适用，每次 next 都会在__iter__()函数中的while循环中不断取值，直到抛出一个IndexError，迭代结束，__iter__()函数结束，for逻辑完成。
生成器读取大文件
引言
有一个数据文件，大小为 10GB
数据只有一行，行中有特殊的分隔符，现在需要剔除分隔符，获得每一个被分隔的元素。
比如，数据文件长这样：
dj134o0kgfdkjfkdjfk'6823sdkfslkfsldkfj'sdkfslfjyerojskfj...
是其中的分隔符
实现过程
def extract(f, sep):
buff = ""
while True:
block = f.read(1024*4)
if not block: # 没读到内容，说明读到尾部了
yield buff # 上次留下来的内容
break
buff += block
while sep in buff:
cut = buff.index(sep) # 定位
yield buff[:cut] # 分隔符前的一个元素
buff = buff[cut + len(sep)] # 跳过分隔符和前面的元素
with open("data.txt") as f:
for line in extract(f, ""):
print(line)
喜欢python + qun：839383765 可以获取Python各类免费最新入门学习资料！