Python——迭代器和解析

Posted 2020-09-26

用迭代工具模拟zip和map

======================================================================

我们已经知道了zip怎样组合可迭代对象，也知道了map怎样映射函数。

>>> S1 = ‘abc‘
>>> S2 = ‘xyz123‘
>>> list(zip(S1,S2))
[(‘a‘, ‘x‘), (‘b‘, ‘y‘), (‘c‘, ‘z‘)]

>>> list(zip([-2,-1,0,1,2]))
[(-2,), (-1,), (0,), (1,), (2,)]

>>> list(map(abs,(-2,-1,0,1,2)))
[2, 1, 0, 1, 2]

>>> list(map(pow,[1,2,3],[2,3,4,5]))
[1, 8, 81]

---------------------------------------------------------------------------------------------------------------

以下就能够编写自己的map(func,...)了

>>> def mymap(func,*seqs):
	res = []
	for args in zip(*seqs):
		res.append(func(*args))
	return res

>>> print(mymap(abs,(-2,-1,0,1,2)))
[2, 1, 0, 1, 2]
>>> print(mymap(pow,[1,2,3],[2,3,4,5]))
[1, 8, 81]

这个版本号依赖于特殊的*args參数传递语法。它手机多个序列參数，将其作为zip參数解包以便组合，然后成对的zip结果解包作为參数以便传入到函数。

也就是说，我们在使用这种一个事实，zip是map中的一个主要的嵌套操作。

【一定要掌握写这样的函数的高级技巧，对參数的处理！】

然而。实际上，前面的版本号展示了列表解析模式，在一个for循环中构建操作结果的一个列表。所以，这个函数还能够精简：

>>> def mymap(func,*seqs):
	return [func(*args) for args in zip(*seqs)]

>>> print(mymap(abs,(-2,-1,0,1,2)))
[2, 1, 0, 1, 2]
>>> print(mymap(pow,[1,2,3],[2,3,4,5]))
[1, 8, 81]

当这段代码执行的时候，结果与前面同样，可是。这段代码更加精炼而且可能执行地更快。
只是。这两个版本号都是一次性构建结果列表，对于较大的列表来说，这可能浪费内存。既然已经知道了生成器函数和表达式，又一次编码这两种替代方案来依据需求产生结果是非常easy的：

>>> def mymap(func,*seqs):
	for args in zip(*seqs):
		yield func(*args)

		
>>> def mymap(func,*seqs):
	return (func(*args) for args in zip(*seqs))

>>> print(list(mymap(pow,[1,2,3],[2,3,4,5])))
[1, 8, 81]

当这段代码执行的时候，结果与前面同样。可是，这段代码更加精炼而且可能执行地更快。

只是。这两个版本号都是一次性构建结果列表，对于较大的列表来说，这可能浪费内存。既然已经知道了生成器函数和表达式。又一次编码这两种替代方案来依据需求产生结果是非常easy的：

>>> def mymap(func,*seqs):
	for args in zip(*seqs):
		yield func(*args)

		
>>> def mymap(func,*seqs):
	return (func(*args) for args in zip(*seqs))

>>> print(list(mymap(pow,[1,2,3],[2,3,4,5])))
[1, 8, 81]

生成器的版本号产生相同的结果，可是返回设计用来支持迭代协议的生成器。

第一个版本号每次yield一个结果。第二个版本号返回一个生成器表达式的结果做相同的事情。

---------------------------------------------------------------------------------------------------------------

编写自己的zip(...)

前述的样例中的魔力在于，它们使用zip内置函数来配对来自多个序列的參数。
以下。我们也来模拟内置的zip。

>>> def myzip(*seqs):
	seqs = [list(S) for S in seqs]
	res = []
	while all(seqs):
		res.append(tuple(S.pop(0) for S in seqs))
	return res

>>> S1,S2 = ‘abc‘,‘xyz123‘
>>> print(myzip(S1,S2))
[(‘a‘, ‘x‘), (‘b‘, ‘y‘), (‘c‘, ‘z‘)]

注意这里的all的内置函数的使用，假设一个可迭代对象中的全部元素为True（或者对等的为非空），它返回True。当列表中有參数在删除后变为了空，这个内置函数用来停止循环。
然而，和前面一样。既然我们的zip构建并返回列表。用yield将它们转换为生成器以便它们每一个都是每次返回结果中的一项，这样来节省内存。

>>> def myzip(*seqs):
	seqs = [list(S) for S in seqs]
	while all(seqs):
		yield tuple(S.pop(0) for S in seqs)

		
>>> list(myzip([1,2,3],(‘a‘,‘b‘,‘c‘,‘d‘)))
[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]

当然，也能够通过计算最小的參数长度来完毕其工作，有了最小长度，非常easy编写编写嵌套的列表解析来遍历參数索引范围

>>> def myzip(*seqs):
	minlen = min(len(S) for S in seqs)
	return [tuple(S[i] for S in seqs) for i in range(minlen)]

>>> myzip([1,2,3],(‘a‘,‘b‘,‘c‘,‘d‘))
[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]

>>> def myzip(*seqs):
	minlen = min(len(S) for S in seqs)
	for i in range(minlen):
		yield tuple(S[i] for S in seqs)

		
>>> list(myzip([1,2,3],(‘a‘,‘b‘,‘c‘,‘d‘)))
[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]

这里第一个样例返回了一个列表。第二个样例使用了生成器函数。但事实上这里也能够使用生成器表达式，反而更精炼：

>>> def myzip(*seqs):
	minlen = min(len(S) for S in seqs)
	return (tuple(S[i] for S in seqs) for i in range(minlen))

>>> myzip([1,2,3],(‘a‘,‘b‘,‘c‘,‘d‘))
<generator object <genexpr> at 0x02BF1B98>
>>> list(myzip([1,2,3],(‘a‘,‘b‘,‘c‘,‘d‘)))
[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]

======================================================================

对迭代的各种方法进行计时

列表解析要比for循环语句有速度方面的性能优势，并且map会根据调用方法的不同表现出更好或更差的性能。生成器表达式看起来比列表解析速度更慢一些。可是它们把内存需求降到了最小。

---------------------------------------------------------------------------------------------------------------

对模块计时

Python对代码计时非常easy。要看看迭代选项是怎样叠加起来的，让我们从编写一个模块文件里的简单但通用的计时器工具函数開始，从而使其能够用于各类程序中。

#File mytimer.py

import time
reps = 1000
repslist = range(reps)

def timer(func,*pargs,**kargs):
    start = time.clock()
    for i in repslist:
        ret = func(*pargs,**kargs)
    elapsed = time.clock() - start
    return (elapsed,ret)

这个模块通过获取时间開始、调用函数固定的次数而且用開始时间减去停止时间。从而对不论什么位置和keyword參数调用随意函数进行计时。

注意下面几点：
（1）Python的time模块同意訪问当前时间。精度随着每一个平台而有所不同。

在Windows上，这个调用号称可以达到微妙的精度。已经相当准确了。
（2）range调用放到了计时循环之外，由于。它的构建成本不会计算到Python2.6的计时器函数中。

在Python3.0中的range是一个迭代器。因此这个步骤是不须要的。
（3）reps计数是一个全局变量，假设须要的话，导入者能够改动它：mytimer.reps = N

当这些完毕后，全部调用的总的时间在一个元祖中返回，还带有被计时的函数的终于返回值，以便调用者能够验证其操作。
---------------------------------------------------------------------------------------------------------------

计时脚本

如今，要计时迭代工具的速度，执行例如以下脚本，它使用已经学习过的各种列表构建技术的相对速度的计时器模块。

# File timeseqs.py

import mytimer,sys
reps = 10000
repslist = range(reps)

def forLoop():
    res = []
    for x in repslist:
        res.append(abs(x))
    return res

def listComp():
    return [abs(x) for x in repslist]

def mapCall():
    return list(map(abs,repslist))

def genExpr():
    return list(abs(x) for x in repslist)

def genFunc():
    def gen():
        for x in repslist:
            yield abs(x)
    return list(gen())

print(sys.version)
for test in (forLoop,listComp,mapCall,genExpr,genFunc):
    elapsed,result = mytimer.timer(test)
    print(‘-‘*33)
    print(‘%-9s:%.5f => [%s...%s]‘%(test.__name__,elapsed,result[0],result[-1]))

这段脚本測试了五种构建结果列表的替代方法。而且，每种方法都运行了一千万次级别的步骤。也就是说。五个測试中的每个都构建了拥有10000个元素的列表1000次。

要注意，底部的代码怎样遍历4个函数对象的一个元祖并打印出每个__name__，这是一个内置的属性。
---------------------------------------------------------------------------------------------------------------

计时结果

在我的Window10电脑上測试。输出了例如以下结果——map比列表解析稍微快一点。但二者都比for循环要快非常多，而且生成器表达式和生成函数速度居中。

>>> 
3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)]
---------------------------------
forLoop  :1.20765 => [0...9999]
---------------------------------
listComp :0.77999 => [0...9999]
---------------------------------
mapCall  :0.67569 => [0...9999]
---------------------------------
genExpr  :0.91294 => [0...9999]
---------------------------------
genFunc  :0.87446 => [0...9999]

假设改动这段脚本。在每次迭代上运行一个真正的操作（如加法）。而不是调用abs这种小的内置函数，五个函数改为：

def forLoop():
    res = []
    for x in repslist:
        res.append(x+10)
    return res

def listComp():
    return [x+10 for x in repslist]

def mapCall():
    return list(map(lambda x:x+10,repslist))

def genExpr():
    return list(x+10 for x in repslist)

def genFunc():
    def gen():
        for x in repslist:
            yield x+10
    return list(gen())

看看測试结果：

>>> 
3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)]
---------------------------------
forLoop  :1.12030 => [10...10009]
---------------------------------
listComp :0.64926 => [10...10009]
---------------------------------
mapCall  :1.35093 => [10...10009]
---------------------------------
genExpr  :0.79881 => [10...10009]
---------------------------------
genFunc  :0.85247 => [10...10009]

这时候，针对map调用的是自己定义的一个lambda函数，所以它比for循环慢。但列表解析依旧是最快的。

解释器优化是内部化的一个问题。像这样对Python代码进行性能分析是一件很须要技术的事情。其实不可能推測哪种方法会运行地更好。并且性能应该不是我们编写Python代码时首要关心的问题——要优化Python代码，首先为了可读性和简单性而编写代码。然后，假设须要的话，再优化。
======================================================================

问题：

1.生成器和迭代器有什么关系？

生成器是支持迭代协议的对象：它们有__next__方法。反复前进到系列结果中的下个元素，以及到系列尾端时引发例外事件。在Python中，我们能够用def、加圆括号的列表解析的生成器表达式以及以类定义特殊方法__iter__来创建生成器对象，通过它们来编写生成器函数。

2.yield语句是做什么的？

当有了yield语句时，这个语句会让Python把函数特定的编译成生成器。当调用时。会返回生成器对象，支持迭代协议。

当yield语句执行时，会把结果返回给调用者，让函数的状态挂起。然后。当调用者再调用__next__方法时。这个函数就能够又一次在上次yield语句后继续执行。生成器也能够有return语句。用来终止生成器。