python迭代和解析(3)：range、map、zip、filter和reduce函數

解析、迭代和生成系列文章：http://www.javashuo.com/article/p-aspbesnv-du.html

---

range

range()是一個內置函數，它返回一個數字序列，功能和Linux下的seq命令差很少。

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(5,10))
[5, 6, 7, 8, 9]

>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

range()返回的是一個可迭代對象(迭代器)，能夠被迭代工具for/in/map/zip等操做。

>>> 1 in range(10)
True

>>> for i in range(10):print(i,end=" ")
...
0 1 2 3 4 5 6 7 8 9

>>> R = range(4)
>>> I = iter(R)
>>> next(I)
0
>>> I.__next__()
1
>>> next(I)
2
>>> next(I)
3
>>> next(I)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

做爲一個可迭代對象，它還支持len()操做和索引操做：

>>> R = range(5)
>>> len(R)
5
>>> R[2]
2

若是想要實現其它功能，能夠將其轉換爲list/tuple/set，而後使用這些類型的功能。

總歸要記住，迭代器是惰性的，不會一次性生成全部數據，而是按需一個一個收集起來的。

正如上面的range()，它不會一次性將全部數字序列都生成出來再返回，而是生成一個返回一個，須要的時候再生成一個返回一個，這可以節約內存空間。

map

map不管在Perl仍是在Python中都是很是強大的工具，Python中map的做用是對給定列表/元組/集合中的每一個元素都應用一個函數操做。

好比，對一系列的數值全都乘2：

>>> def time2(x):return 2*x
>>> M = map(time2, [1,2,3,4,5])
>>> M
<map object at 0x000001AFDC2C57B8>
>>> list(M)
[2, 4, 6, 8, 10]

再好比將字符串中的字符全都轉換成大寫，此次直接將map的結構所有收集到一個列表中：

>>> list( map(str.upper,"abcd") )
['A', 'B', 'C', 'D']

map支持多個元素集合，它會每次從這些元素集合中並行取出一個元素做爲函數的參數：

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

第一次取出1和2做爲pow的參數，因此計算的是pow(1,2)獲得1；第二次取出2和3做爲pow的參數，因此計算的是pow(2,3)獲得8，第三次取出的是3和4，因此計算的是pow(3,4)獲得81。

對於map，有幾個注意點：

1. map能夠有多個參數，從第二個參數開始是元素集合，這些元素集合能夠是任意可迭代對象，好比內置容器類型、range等
   
2. map的第一個參數是想要對每一個元素進行操做的函數，能夠是已定義的函數，也能夠是lambda。它是map的回調函數
   • 若是是已定義的函數，則只需傳遞函數名稱
     
   • 若是是lambda，則須要指定正確數量的參數
     
3. map自身返回的就是迭代器，也就是說它本身是本身的迭代器
   
4. map是迭代操做，因此它的工做方式是惰性的，按需一次返回一個數據，而不是收集完全部數據後一次性返回
   
5. 全部map操做都能替換成等價的for循環，但map的效率比for要高的多，基本能和解析操做的效率差很少

由於map返回的是自身的迭代器，因此能夠被for/map/zip/in等迭代工具操做，例如手動迭代：

>>> 2 in map(time2,[1,2,3,4,5])
True

>>> M = map(str.upper,"abcd")
>>> M
<map object at 0x000001AFDC2C5748>
>>> next(M)
'A'
>>> next(M)
'B'
>>> next(M)
'C'
>>> next(M)
'D'
>>> next(M)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

例如，使用lambda做爲map的第一個回調函數的參數：

>>> M = map(lambda x: x * 2, [2,3,4,5])
>>> list(M)
[4, 6, 8, 10]

因爲map操做的是迭代器中的每一個元素，因此map通常均可以寫成等價的列表解析操做。

>>> [ x * 2 for x in [1,2,3,4,5] ]
[2, 4, 6, 8, 10]

>>> list( map(lambda x: x * 2, [1,2,3,4,5]) )
[2, 4, 6, 8, 10]

通常來講，若是map中使用了lambda，則map效率要稍低於列表解析，若是沒有使用lambda，則map效率要稍高於列表解析。雖然它們效率差很少，可是若是能夠的話，強烈建議使用列表解析，由於列表解析是python中極簡潔、極可讀的編碼方式。

zip

zip()函數能夠從一個或多個可迭代對象中並行取出元素進行並行的迭代。它也是返回自身的迭代器。

例如：

>>> L1 = ["one","two","three"]
>>> L2 = [1,2,3]

>>> zip(L1,L2)
<zip object at 0x000001AFDC2D9A08>
>>> list(zip(L1,L2))
[('one', 1), ('two', 2), ('three', 3)]

之因此能並行迭代多個可迭代對象，是由於它同時標記多個可迭代對象的迭代位置。若是zip的多個可迭代對象的長度不一樣，則以最短的長度爲標準，由於zip最多隻能標記到最短長度的迭代位置。

由於zip返回的是迭代器，因此可使用迭代工具去操做zip的結果：

>>> L1 = ["one","two","three"]
>>> L2 = [1,2,3]

>>> ("one",1) in zip(L1,L2)
True

>>> for (x,y) in zip(L1,L2):print(x,"-->",y)
...
one --> 1
two --> 2
three --> 3

zip經常使用於構建dict，由於它並行從多個迭代對象中取數據：

>>> L1 = ["one","two","three"]
>>> L2 = [1,2,3]

>>> dict(zip(L1,L2))
{'one': 1, 'two': 2, 'three': 3}

須要注意的是，zip能夠從任意可迭代對象中取元素，而集合/字典中的元素順序是不定的，因此並行取出來的順序可能不像想象中在位置上那般一一對應。

>>> L1={"one","two","three"}
>>> L2=[1,2,3]
>>> list(zip(L1,L2))
[('one', 1), ('three', 2), ('two', 3)]

filter

Python中的filter函數相似於Perl中的grep，用於從可迭代對象中篩選出元素被函數操做後爲True的元素。

filter(function or None, iterable) --> filter object

例如，篩選出列表中字符串元素長度大於2的字符串：

>>> L = ["a","ab","abc","abcd"]
>>> L1 = filter( (lambda x: len(x) > 2), L )
>>> print(list(L1))
['abc', 'abcd']

上面的工做過程是迭代列表L，每取一個元素都放進函數中操做一番，若是這個元素放進函數中使得函數返回真，則保留這個元素，不然丟棄這個元素。

若是filter的函數部分爲None，則表示直接從可迭代對象中取出元素爲True的元素：

>>> list(filter(None,["a","ab",0,"","c"]))
['a', 'ab', 'c']

filter的返回結果是一個可迭代對象，能夠進行迭代操做：

>>> for i in filter( (lambda x: len(x) > 2), L ): print(i)
...
abc
abcd

reduce

reduce的功能很是好用，看下面的示例：

>>> import functools
>>> functools.reduce(lambda x, y: x+y, [1,2,3,4,5])
15

它的語法爲：

reduce(func, sequence[, initial]) -> value

reduce有兩個過程：

1. 先從sequence中取兩個元素做爲func的參數，該函數返回一個結果A。這是初始化的過程
   
2. 將結果A與sequence的下一個元素做爲func的參數，繼續返回一個結果B，將結果B與下一個元素做爲func參數，依次類推，直到迭代完sequence中全部元素

若是給reduce設置了initial參數，則跳過初始化的過程，直接將Initial與sequence的第一個元素做爲func的參數。若是沒有給定sequence，而給了Initial，則initial做爲直接返回的默認值。

例如，從序列中取出最大值：

>>> reduce( lambda x, y: x if x > y else y, [1,2,3,4,5] )
5

>>> reduce( lambda x, y: x if x>y else y, [1,2,3,4,5],10 )
10

多迭代和單迭代

range()和zip()、map()、filter()稍有不一樣。range()支持多迭代、然後三者只支持單迭代。

何爲單迭代、何爲多迭代？多迭代的意思是同一個對象上能夠有多個互不影響的獨立迭代器，各迭代器本身記住本身的迭代位置(狀態信息)。單迭代的意思是同一個對象上只能有一個迭代器，即便建立了多個迭代器，它們也是串聯起來互相影響的。

下面是range()的多迭代特性：

>>> R = range(3)   # 一個range對象R
>>> I1 = iter(R)   # range對象的一個迭代器
>>> I2 = iter(R)   # range對象的第二個迭代器
>>> next(I1)
0
>>> next(I1)
1
>>> next(I2)     # 和I1互不影響
0
>>> next(I2)
1
>>> next(I1)
2

下面的zip、map、filter單迭代的特性：

# zip的單迭代
>>> Z = zip([1,2,3],[10,11,12]) # 自身是迭代器
>>> I1 = iter(Z)       # 從自身獲取可迭代對象I1
>>> I2 = iter(Z)       # 從自身獲取可迭代對象I2
>>> next(I1)
(1, 10)
>>> next(I2)  # I1和I2迭代的是同一個對象：自身
(2, 11)
>>> next(I1)
(3, 12)

之因此range()支持多迭代，而zip/map/filter都只支持單迭代，是由於：

1. zip/map/filter返回的是自身的迭代器，它們的返回結果自身同時都實現了__iter__()和__next__()兩個方法，因此不管從它們的返回結果上產生多少個可迭代對象，操做的都是它們的對象自身，從而只支持單迭代
   
2. range返回的不是自身迭代器，它的返回結果只實現了__iter__而沒有實現__next__，因此須要經過iter()來生成可迭代對象(迭代器)。不管使用iter()從該返回結果產生多少個可迭代對象，都是互相獨立的可迭代對象，從而支持多迭代

因此通常來講，不是自身迭代器的對象支持多個迭代器，而自身是自身迭代器的對象只支持單個迭代器。

常見的多迭代有range()和那些支持迭代的內置類型，好比字符串、列表、元組等。例如字符串的多迭代：

>>> S = "abc"
>>> for x in S:
...   for y in S:
...     print(x + y, end=" ")
aa ab ac ba bb bc ca cb cc