range range()是一個內置函數,它返回一個數字序列,功能和Linux下的seq命令差不多。 range()返回的是一個可迭代對象(迭代器),可以被迭代工具for/in/map/zip等操作。 作為一個可迭代對象,它還支持len()操作和索引操作: 如果想要實現其它功能,可以將其轉換為lis ...
解析、迭代和生成系列文章:https://www.cnblogs.com/f-ck-need-u/p/9832640.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,有幾個註意點:
- map可以有多個參數,從第二個參數開始是元素集合,這些元素集合可以是任意可迭代對象,比如內置容器類型、range等
- map的第一個參數是想要對每個元素進行操作的函數,可以是已定義的函數,也可以是lambda。它是map的回調函數
- 如果是已定義的函數,則只需傳遞函數名稱
- 如果是lambda,則需要指定正確數量的參數
- 如果是已定義的函數,則只需傳遞函數名稱
- map自身返回的就是迭代器,也就是說它自己是自己的迭代器
- map是迭代操作,所以它的工作方式是惰性的,按需一次返回一個數據,而不是收集完所有數據後一次性返回
- 所有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有兩個過程:
- 先從sequence中取兩個元素作為func的參數,該函數返回一個結果A。這是初始化的過程
- 將結果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都只支持單迭代,是因為:
- zip/map/filter返回的是自身的迭代器,它們的返回結果自身同時都實現了
__iter__()
和__next__()
兩個方法,所以無論從它們的返回結果上產生多少個可迭代對象,操作的都是它們的對象自身,從而只支持單迭代
- 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