Python | Hugo Academic Blog Theme

Python 之迭代器与生成器

Tue, 12 Mar 2019 19:41:40 +0000

Python中的迭代器和生成器是对于初学者来说很容易混淆，更说不出两者的区别。当然这也是面试中的常考内容，我今天将要详细介绍下它们。

迭代器

Python中的对象之所以能迭代是因为对象定义(或继承)了**__iter__或__getitem__**。

在需要迭代对象的时候，解释器会首先调用iter函数，iter的执行过程为：

查找对象是否存在**__iter__方法, 如果存在则调用，如果__iter__**返回的值是迭代器对象（Iterator），则直接返回，反之则报错,例如：

TypeError: iter() returned non-iterator of type ‘int’

如果没有实现**__iter__方法,则会查看是否实现了__getitem__**方法，如果实现，则会生成一个迭代器,并返回。该迭代器在迭代时会尝试通过索引（从0开始）获取元素，直到抛出IndexError。
如果两个方法都没有实现，则会抛出异常（其中Iter为对象所属的类）:

TypeError: ‘Iter’ object is not iterable

由此可以看出：迭代器是从可迭代对象中获取的。 我们需要知道，**可迭代和迭代器是不一样的。**这可根据官方源码看出：

def _check_methods(C, *methods):
mro = C.__mro__
for method in methods:
for B in mro:
if method in B.__dict__:
if B.__dict__[method] is None:
return NotImplemented
break
else:
return NotImplemented
return True
class Iterable(metaclass=ABCMeta):
__slots__ = ()
@abstractmethod
def __iter__(self):
while False:
yield None
@classmethod
def __subclasshook__(cls, C):
if cls is Iterable:
return _check_methods(C, "__iter__")
return NotImplemented
class Iterator(Iterable):
__slots__ = ()
@abstractmethod
def __next__(self):
'Return the next item from the iterator. When exhausted, raise StopIteration'
raise StopIteration
def __iter__(self):
return self
@classmethod
def __subclasshook__(cls, C):
if cls is Iterator:
return _check_methods(C, '__iter__', '__next__')
return NotImplemented

可以看出Iterator需要实现**__iter__和__next__，而Iterable只需要实现__iter__**就行。

内置类型（str，dict，list，tuple，set）的实例对象只是Iterable，却不算是Iterator。

例如：

from collections.abc import Iterable,Iterator
print(isinstance("xzyl", Iterable)) # True
print(isinstance("xzyl", Iterator)) # False
class It1:
def __iter__(self):
pass
class It2:
def __iter__(self):
pass
def __next__(self):
pass
print(isinstance(It1(), Iterable)) # True
print(isinstance(It2(), Iterable)) # True
print(isinstance(It1(), Iterator)) # False
print(isinstance(It2(), Iterator)) # True

从上面的信息来看，判断对象是否可迭代的最准确的方法是通过调用iter方法然后捕获TypeError了，因为实现序列协议**__getitem__的对象也是可迭代的。并且定义了__iter__**方法也不一定就表示该对象可迭代了，例如返回一个整数或字符串等。

虽然可迭代对象可以定义为迭代器，但是我们不推荐这样做，后面会分享设计模式中的迭代器模式，来说明好的设计为何不应该这样做。

生成器

在了解什么是生成器之前，我们先了解下生成器函数：

def counter():
for i in range(1,11):
yield i
print(counter) # <function __main__.counter()>
print(counter()) # <generator object counter at 0x000001B6BB7D2660>

正如上面看到的，函数体中有yield关键字的函数即为生成器函数。生成器函数自身跟普通函数没有区别，但是在调用时会返回一个生成器对象，是生成器对象的生产工厂。

生成器对象同样是迭代器对象。

print(isinstance(counter, Iterator)) # True

生成器同时拥有延迟计算的特点：

def counter():
for i in range(1,3):
print(i)
yield i
c = counter()
print(next()) # 1
print(next()) # 2
print(next()) # raise StopIteration

由于生成器延迟计算的特点，可以在读取大数据时节省很大内存。

区别

个人总结两者的区别有：

两者的生成方式不同

迭代器对象是实现了迭代器协议(__iter__和__next__)的对象，而生成器对象则是通过调用生成器函数(含yield关键字)或者生成器推导式生成

生成器一定是迭代器，但迭代器不一定是生成器（生成器是迭代器的子类）

生成器同样实现了迭代器协议

两者的数据源不一样

迭代器需要确定的原始数据，而生成器可以不需要数据（如果你想，你可以一直在函数中yield值）。

生成器有send方法，而迭代器不一定有

总体来说在以遍历为目的的时候，两者并无太大区别，但是生成器写法更加简洁。

生成器更加重要的作用是在协程部分，以后将会分享。

Python中的延迟绑定

Tue, 05 Mar 2019 11:30:16 +0000

延迟绑定出现在闭包问题中。下面我们看一个闭包的例子：

def gen_mul(n):
def mul(x):
return n*x
return mul
double = gen_mul(2)
doubled_value = double(6) # 12

可以看出满足闭包的几点：

有内部函数
内部函数引用了外部函数中的自由变量
内部函数被返回

闭包的优点：

可以避免使用全局变量
可以持久化变量，达到静态变量的作用

闭包的缺点：

可能会消耗大量的内存
可能会导致内存泄漏

当然缺点可以通过人为避免。

现在我们来看看另一个会引出延迟绑定的例子：

def multipliers():
return [lambda x : i * x for i in range(4)]
print([m(2) for m in multipliers()]) # [6,6,6,6]

上边的例子会输出**[6,6,6,6],而不是我们预期的[0,2,4,6]**。

这就是延迟绑定导致的结果。具体过程我们可以来分析下：执行第三行时，会先执行multipliers函数，然后执行函数中的列表解析式。在每一次迭代的时候都会生成一个匿名函数(这里只是定义)作为元素。然后回到第三行，遍历返回的列表中的匿名函数，传入参数2并执行。此时函数类似于这样：

def noname(x):
return i * x

我们知道Python查找变量的作用域链的顺序依次为**LEGB**：

局部变量(L)->外部函数中的局部变量(E)->全局变量(G)->内置变量(B)

非常重要的一点我们需要知道：Python的作用域在编译时就已经形成了，而不是在运行时，函数的作用域与其被调用的位置无关。

那么在本例中,上面的noname函数体中的i从何而来呢？当然首先会到multipliers函数的局部变量中去寻找。此时i的值已经为3，所以出现这种让人"费解"的现象。

那么现在我们既然已经知道了原因，那么要怎样解决呢？

我们可以将迭代的i值直接注入到匿名函数的函数体中，这里给出两种方法：

通过为参数设置默认值，这是因为在编译时就会计算确定默认值：

def multipliers_ch1():
return [lambda m,x=i : m * x for i in range(4)]

通过内置函数partial：

from functools import partial
def multipliers_ch2():
return [partial(lambda m,x : m * x,i) for i in range(4)]

利用生成器的延迟计算：

def multipliers_ch3():
for m in range(4):
yield lambda x: m * x

partial及生成器的内容会在以后分享。

运行结果

print([m(2) for m in multipliers_ch1()]) # [0,2,4,6]
print([m(2) for m in multipliers_ch2()]) # [0,2,4,6]
print([m(2) for m in multipliers_ch3()]) # [0,2,4,6]

注:

自由变量：指未在本地作用域中绑定的变量，我们可通过访问函数的**__code__**属性进行查看：

fun.__code__.co_freevars

LEGB: 可看该部分解释

Python | Hugo Academic Blog Theme

Python 之 迭代器与生成器

迭代器

生成器

区别

Python中的延迟绑定

注:

Python 之迭代器与生成器