Python学习手册（第四部分函数）第20章 迭代和解析 第二部分

重访迭代器：生成器

生成器提供了工具在需要的时候才产生结果，而不是立即产生结果。

1. 生成器函数：编写为常规的def语句，但是使用yield语句一次返回一个结果，而不是立即产生结果。
2. 生成器表达式：类似于上一小节的列表解析，但是，它们返回按需产生结果的一个对象，而不是构建一个结果列表。

由于二者都不会一次性构建一个列表，它们节省了内存空间，并且允许计算时间分散到各个结果请求。

生成器函数应用 

>>> def gensquares(N):
...     for i in range(N):
...             yield i**2
...
>>> for i in gensquares(5):
...     print(i,end=":")
...
0:1:4:9:16:>>> x = gensquares(2)
>>> x
<generator object gensquares at 0x00000156F3A47D00>
>>> next(x)
0
>>> next(x)
1
>>> next(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

生成器表达式：迭代器遇上列表解析

>>> [x**2 for x in range(4)]
[0, 1, 4, 9]
>>> (x**2 for x in range(4))
<generator object <genexpr> at 0x00000156F3A47D00>
>>> G = (x**2 for x in range(4))
>>> next(G)
0
>>> next(G)
1
>>> next(G)
4
>>> next(G)
9
>>> next(G)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> for num in (x**2 for x in range(4)):
...     print("%s,%s"%(num,num/2.0))
...
0,0.0
1,0.5
4,2.0
9,4.5
>>> sum(x**2 for x in range(4))
14
>>> sorted(x**2 for x in range(4))
[0, 1, 4, 9]
>>> sorted((x**2 for x in range(4)),reverse=True)
[9, 4, 1, 0]
>>> import math
>>> list(map(math.sqrt,(x**2 for x in range(4))))
[0.0, 1.0, 2.0, 3.0]

生成器函数vs生成器表达式

生成器是单迭代器

>>> G = (c*2 for c in "spam")
>>> I = iter(G)
>>> next(I)
'ss'
>>> next(I)
'pp'
>>> next(I)
'aa'
>>> I1= iter(G)
>>> next(I1)
'mm'
>>> next(I1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration


# 列表等内置类型支持多个迭代器并且在一个活动迭代器中传递并反映他们的原处修改
>>> L = [1,2,3,4]
>>> I1 = iter(L)
>>> next(I1)
1
>>>
>>> next(I1)
2
>>> I2 = iter(L)
>>> next(I2)
1
>>> next(I2)
2
>>> del L[2:]
>>> next(I1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

编写自己的zip和map

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

def mymapPad(*seqs,pad=None):
    seqs = [list(S) for S in seqs]
    while any(seqs):
        yield tuple((S.pop(0) if S else pad) for S in seqs)

S1,S2 = 'abc','xyz123'
print(list(myzip(S1,S2)))
print(list(mymapPad(S1,S2)))
print(list(mymapPad(S1,S2,pad=99)))

#结果如下
[('a', 'x'), ('b', 'y'), ('c', 'z')]
[('a', 'x'), ('b', 'y'), ('c', 'z'), (None, '1'), (None, '2'), (None, '3')]
[('a', 'x'), ('b', 'y'), ('c', 'z'), (99, '1'), (99, '2'), (99, '3')]

#或者函数也可以这样写，结果一样
def myzip(*seqs):
    minlen = min(len(S) for S in seqs)
    return [tuple(S[i] for S in seqs) for i in range(minlen)]
def mymapPad(*seqs,pad=None):
    maxlen  = max(len(S) for S in seqs)
    index = range(maxlen)
    return [tuple((S[i] if len(S) > i else pad) for S in seqs) for i in index]

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

# File mytimer.py

import time,sys
if sys.platform[:3] == 'win':
    timefunc = time.clock
else:
    timefunc = time.time

def trace(*args):pass

def timer(func,*pargs,**kargs):
    _reps = kargs.pop('_reps',1000)
    trace(func,pargs,kargs,_reps)
    repslist = range(_reps)
    start = timefunc()
    for i in repslist:
        ret = func(*pargs,**kargs)
    elapsed = timefunc() - start
    return (elapsed,ret)

def best(func,*pargs,**kargs):
    _reps = kargs.pop('_reps',50)
    best = 2**32
    for i in range(_reps):
        (time,ret)=timer(func,*pargs,_reps=1,**kargs)
        if time < best:best = time
    return (best,ret)

# File timeseqs.py

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

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())

print(sys.version)
for tester in (mytimer.timer,mytimer.best):
    print('<%s>'%tester.__name__)
    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]))

# file timetests.py

from mytimer import timer,best
def power(X,Y):return X**Y

print(timer(power,2,32))
print(timer(power,2,32,_reps=1000000))
print(timer(power,2,100000)[0])

print(best(power,2,32))
print(best(power,2,100000)[0])
print(best(power,2,100000,_reps=500)[0])

函数陷阱

本地变量是静态检测的