python入门系列：迭代器和生成器

落日映苍穹つ 2022-10-01 14:50 198阅读 0赞

python的迭代协议

引言

迭代器是访问集合内部元素的一种方式，一般用来遍历数据。  
迭代器和用下标索引访问的方式不一样，迭代器是不能直接返回值的。  
迭代器提供了一种惰性访问数据的方式，需要的时候才产生数据。  
可迭代类型都实现了迭代协议，实际上就是**iter**()这个魔法函数。  
可迭代类型和迭代器

前面讲过，collections.abc模块中定义了很多内置的抽象基类，现在我们重点关注其中的两个：Iterable 和 Iterator

Iterable  
![python入门系列：迭代器和生成器][python]  
里面定义了一个抽象方法，**iter**()，也就是说某个类只要实现了这个魔法函数，它就是可迭代的类型

Iterator  
![python入门系列：迭代器和生成器][python 1]  
首先，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: #

# <iterator object at 0x000002043CEE4F28> #

如果我们不实现**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: #

# <generator object gen\_func at 0x000001B102C3C0F8> #

# 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各类免费最新入门学习资料！

转载于:https://blog.51cto.com/14186420/2349828

[python]: https://s1.51cto.com/images/blog/201902/13/5c56eefca5b7fd13cdb1126d66085432.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=
[python 1]: https://s1.51cto.com/images/blog/201902/13/3285dfdc5dd053da9a790c73248b5105.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=