說到處理循環(huán)，我們習慣使用for,while等，比如依次打印每個列表中的字符：

lis=['I','love','python']

foriinlis:

print(i)

I

love

python

在打印內容字節(jié)數較小時，全部載入內存后，再打印，沒有問題?？墒牵绻F在有成千上百萬條車輛行駛軌跡，叫你分析出其中每個客戶的出行規(guī)律，堵車情況等，假如是在單機上處理這件事。

你可能首先要面臨，也可能被你忽視，最后代碼都寫好后，才可能暴露出的一個問題:outofmemory,這在實際項目中經常遇到。

這個問題提醒我們，處理數據時，如何寫出高效利用內存的程序，就顯得很重要。今天，我們就來探討如何高效利用內存，節(jié)省內存同時還能把事情辦好。

其實，Python已經準備好一個模塊專門用來處理這件事，它就是itertools模塊，這里面幾個函數的功能其實很好理解。

我不打算籠統的介紹它們所能實現的功能，而是想分析這些功能背后的實現代碼，它們如何做到高效節(jié)省內存的，Python內核的貢獻者們又是如何寫出一手漂亮的代碼的，這很有趣，不是嗎?

OK，let'sgo.Hopeyouenjoythejourney!

1、拼接元素

itertools中的chain函數實現元素拼接，原型如下，參數*表示個數可變的參數

chain(iterables)

應用如下：

In[33]:list(chain(['I','love'],['python'],['very','much']))

Out[33]:['I','love','python','very','much']

哇，不能再好用了，它有點join的味道，但是比join強，它的重點在于參數都是可迭代的實例。

那么，chain如何實現高效節(jié)省內存的呢?chain大概的實現代碼如下：

defchain(*iterables):

foritiniterables:

forelementinit:

yieldelement

以上代碼不難理解，chain本質返回一個生成器，所以它實際上是一次讀入一個元素到內存，所以做到最高效地節(jié)省內存。

2、逐個累積

返回列表的累積匯總值，原型：

accumulate(iterable[,func,*,initial=None])

應用如下：

In[36]:list(accumulate([1,2,3,4,5,6],lambdax,y:x*y))

Out[36]:[1,2,6,24,120,720]

accumulate大概的實現代碼如下：

defaccumulate(iterable,func=operator.add,*,initial=None):

it=iter(iterable)

total=initial

ifinitialisNone:

try:

total=next(it)

exceptStopIteration:

return

yieldtotal

forelementinit:

total=func(total,element)

yieldtotal

以上代碼，你還好嗎?與chain簡單的yield不同，此處稍微復雜一點，yield有點像return，所以yieldtotal那行直接就返回一個元素，也就是iterable的第一個元素，因為任何時候這個函數返回的第一個元素就是它的第一個。又因為yield返回的是一個generator對象，比如名字gen，所以next(gen)時，代碼將會執(zhí)行到forelementinit:這行，而此時的迭代器it已經指到iterable的第二個元素，OK，相信你懂了!

3、漏斗篩選

它是compress函數，功能類似于漏斗功能，所以我稱它為漏斗篩選，原型：

compress(data,selectors)

In[38]:list(compress('abcdefg',[1,1,0,1]))

Out[38]:['a','b','d']

容易看出，compress返回的元素個數等于兩個參數中較短的列表長度。

它的大概實現代碼：

defcompress(data,selectors):

return(dford,sinzip(data,selectors)ifs)

這個函數非常好用

4、段位篩選

掃描列表，不滿足條件處開始往后保留，原型如下：

dropwhile(predicate,iterable)

應用例子：

In[39]:list(dropwhile(lambdax:x<3,[1,0,2,4,1,1,3,5,-5]))

Out[39]:[4,1,1,3,5,-5]

實現它的大概代碼如下：

defdropwhile(predicate,iterable):

iteriterable=iter(iterable)

forxiniterable:

ifnotpredicate(x):

yieldx

break

forxiniterable:

yieldx

5、段位篩選2

掃描列表，只要滿足條件就從可迭代對象中返回元素，直到不滿足條件為止，原型如下：

takewhile(predicate,iterable)

應用例子：

In[43]:list(takewhile(lambdax:x<5,[1,4,6,4,1]))

Out[43]:[1,4]

實現它的大概代碼如下：

deftakewhile(predicate,iterable):

forxiniterable:

ifpredicate(x):

yieldx

else:

break#立即返回

6、次品篩選

掃描列表，只要不滿足條件都保留，原型如下：

dropwhile(predicate,iterable)

應用例子：

In[40]:list(filterfalse(lambdax:x%2==0,[1,2,3,4,5,6]))

Out[40]:[1,3,5]

實現它的大概代碼如下：

defdropwhile(predicate,iterable):

iteriterable=iter(iterable)

forxiniterable:

ifnotpredicate(x):

yieldx

break

forxiniterable:

yieldx

7、切片篩選

Python中的普通切片操作，比如：

lis=[1,3,2,1]

lis[:1]

它們的缺陷還是lis必須全部載入內存，所以更節(jié)省內存的操作islice，原型如下：

islice(iterable,start,stop[,step])

應用例子：

In[41]:list(islice('abcdefg',1,4,2))

Out[41]:['b','d']

實現它的大概代碼如下：

defislice(iterable,*args):

s=slice(*args)

start,stop,sstep=s.startor0,s.stoporsys.maxsize,s.stepor1

it=iter(range(start,stop,step))

try:

nextnexti=next(it)

exceptStopIteration:

fori,elementinzip(range(start),iterable):

pass

return

try:

fori,elementinenumerate(iterable):

ifi==nexti:

yieldelement

nextnexti=next(it)

exceptStopIteration:

fori,elementinzip(range(i+1,stop),iterable):

pass

巧妙利用生成器迭代結束時會拋出異常StopIteration，做一些邊界處理的事情。

8、細胞分裂

tee函數類似于我們熟知的細胞分裂，它能復制原迭代器n個，原型如下：

tee(iterable,n=2)

應用如下，可以看出復制出的兩個迭代器是獨立的

a=tee([1,4,6,4,1],2)

In[51]:next(a[0])

Out[51]:1

In[52]:next(a[1])

Out[52]:1

實現它的代碼大概如下：

deftee(iterable,n=2):

it=iter(iterable)

deques=[collections.deque()foriinrange(n)]

defgen(mydeque):

whileTrue:

ifnotmydeque:

try:

newval=next(it)

exceptStopIteration:

return

fordindeques:

d.append(newval)

yieldmydeque.popleft()

returntuple(gen(d)fordindeques)

tee實現內部使用一個隊列類型deques，起初生成空隊列，向復制出來的每個隊列中添加元素newval,同時yield當前被調用的mydeque中的最左元素。

9、map變體

starmap可以看做是map的變體，它能更加節(jié)省內存，同時iterable的元素必須也為可迭代對象，原型如下：

starmap(function,iterable)

應用它：

In[63]:list(starmap(lambdax,y:str(x)+'-'+str(y),[('a',1),('b',2),('c',3)]))

Out[63]:['a-1','b-2','c-3']

starmap的實現細節(jié)如下：

defstarmap(function,iterable):

forargsiniterable:

yieldfunction(*args)

10、復制元素

repeat實現復制元素n次，原型如下：

repeat(object[,times])

應用如下：

In[66]:list(repeat(6,3))

Out[66]:[6,6,6]

In[67]:list(repeat([1,2,3],2))

Out[67]:[[1,2,3],[1,2,3]]

它的實現細節(jié)大概如下：

defrepeat(object,times=None):

iftimesisNone:#如果times不設置，將一直repeat下去

whileTrue:

yieldobject

else:

foriinrange(times):

yieldobject

11、笛卡爾積

笛卡爾積實現的效果同下：

((x,y)forxinAforyinB)

所以，笛卡爾積的實現效果如下：

In[68]:list(product('ABCD','xy'))

Out[68]:

[('A','x'),

('A','y'),

('B','x'),

('B','y'),

('C','x'),

('C','y'),

('D','x'),

('D','y')]

它的實現細節(jié)：

defproduct(*args,repeat=1):

pools=[tuple(pool)forpoolinargs]*repeat

result=[[]]

forpoolinpools:

result=[x+[y]forxinresultforyinpool]

forprodinresult:

yieldtuple(prod)

12、加強版zip

組合值。若可迭代對象的長度未對齊，將根據fillvalue填充缺失值，注意：迭代持續(xù)到耗光最長的可迭代對象，效果如下：

In[69]:list(zip_longest('ABCD','xy',fillvalue='-'))

Out[69]:[('A','x'),('B','y'),('C','-'),('D','-')]

它的實現細節(jié)：

defzip_longest(*args,fillvalue=None):

iterators=[iter(it)foritinargs]

num_active=len(iterators)

ifnotnum_active:

return

whileTrue:

values=[]

fori,itinenumerate(iterators):

try:

value=next(it)

exceptStopIteration:

num_active-=1

ifnotnum_active:

return

iterators[i]=repeat(fillvalue)

value=fillvalue

values.append(value)

yieldtuple(values)

它里面使用repeat，也就是在可迭代對象的長度未對齊時，根據fillvalue填充缺失值。理解上面代碼的關鍵是迭代器對象(iter)，next方法的特殊性：I

n[74]:fori,itinenumerate([iter([1,2,3]),iter(['x','y'])]):

...:print(next(it))

#輸出：

1

x

結合這個提示再理解上面代碼，就不會吃力。

總結

Python的itertools模塊提供的節(jié)省內存的高效迭代器，里面實現基本都借助于生成器，所以一方面了解這12個函數所實現的基本功能，同時也能加深對生成器(generator)的理解，為我們寫出更加高效、簡潔、漂亮的代碼打下堅實基礎。

以上內容為大家介紹了Python循環(huán)應該怎么寫?希望對大家有所幫助，如果想要了解更多Python相關知識，請關注IT培訓機構:千鋒教育。http://m.2667701.com/