Python 利用itertools模塊生成迭代器

今天就跟大家聊聊有關(guān)Python 利用itertools模塊生成迭代器，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結(jié)了以下內(nèi)容，希望大家根據(jù)這篇文章可以有所收獲。

itertools 模塊中主要包含了一些用于生成迭代器的函數(shù)。在 Python 的交互式解釋器中先導(dǎo)入 itertools 模塊，然后輸入 [e for e in dir(itertools) if not e.startswith('_')] 命令，即可看到該模塊所包含的全部屬性和函數(shù)：

>>> [e for e in dir(itertools) if not e.startswith('_')]
['accumulate', 'chain', 'combinations', 'combinations_with_replacement', 'compress', 'count', 'cycle', 
'dropwhile', 'filterfalse', 'groupby', 'islice', 'permutations', 'product', 'repeat', 'starmap', 'takewhile',
 'tee', 'zip_longest']

從上面的輸出結(jié)果可以看出，itertools 模塊中的不少函數(shù)都可以用于生成迭代器。

先看 itertools 模塊中三個生成無限迭代器的函數(shù)：

count(start, [step])：生成 start, start+step, start+2*step，... 的迭代器，其中 step 默認(rèn)為 1。比如使用 count(10) 生成的迭代器包含：10, 11 , 12 , 13, 14，...。

cycle(p)：對序列 p 生成無限循環(huán) p0, p1,..., p0, p1,... 的迭代器。比如使用 cycle('ABCD') 生成的迭代器包含：A,B,C,D,A,B,C,D,...。

repeat(elem [,n])：生成無限個 elem 元素重復(fù)的迭代器，如果指定了參數(shù) n，則只生成 n 個 elem 元素。比如使用 repeat(10, 3) 生成的法代器包含：10, 10, 10。

下面程序示范了使用上面三個函數(shù)來生成迭代器：

import itertools as it
# count(10, 3)生成10、13、16……迭代器
for e in it.count(10, 3):
    print(e)
    # 用于跳出無限循環(huán)
    if e > 20:
        break
print('---------')
my_counter = 0
# cycle用于對序列生成無限循環(huán)的迭代器
for e in it.cycle(['Python', 'Kotlin', 'Swift']):
    print(e)
    # 用于跳出無限循環(huán)
    my_counter += 1
    if my_counter > 7:
        break
print('---------')
# repeat用于生成n個元素重復(fù)的迭代器
for e in it.repeat('Python', 3):
    print(e)

在 itertools 模塊中還有一些常用的迭代器函數(shù)，如下所示：

accumulate(p[,func])：默認(rèn)生成根據(jù)序列 p 元素累加的迭代器，p0, p0+p1, p0+p1+p2，...序列，如果指定了 func 函數(shù)，則用 func 函數(shù)來計算下一個元素的值。

chain(p, q, ...)：將多個序列里的元素“鏈”在一起生成新的序列。

compress(data, selectors)：根據(jù) selectors 序列的值對 data 序列的元素進(jìn)行過濾。如果 selector[0] 為真，則保留 data[0]；如果 selector[1] 為真，則保留 data[1]......依此類推。

dropwhile(pred, seq)：使用 pred 函數(shù)對 seq 序列進(jìn)行過濾，從 seq 中第一個使用 pred 函數(shù)計算為 False 的元素開始，保留從該元素到序列結(jié)束的全部元素。

takewhile(pred, seq)：該函數(shù)和上一個函數(shù)恰好相反。使用 pred 函數(shù)對 seq 序列進(jìn)行過濾，從 seq 中第一個使用 pred 函數(shù)計算為 False 的元素開始，去掉從該元素到序列結(jié)束的全部元素。

filterfalse(pred, seq)：使用 pred 函數(shù)對 seq 序列進(jìn)行過濾，保留 seq 中使用 pred 計算為 True 的元素。比如 filterfalse(lambda x:x%2, range(10))，得到 0, 2, 4, 6, 8。

islice(seq, [start,] stop [, step])：其功能類似于序列的 slice 方法，實際上就是返回 seq[start:stop:step] 的結(jié)果。

starmap(func, seq)：使用 func 對 seq 序列的每個元素進(jìn)行計算，將計算結(jié)果作為新的序列元素。當(dāng)使用 func 計算序列元素時，支持序列解包。比如 seq 序列的元素長度為 3，那么 func 可以是一個接收三個參數(shù)的函數(shù)，該函數(shù)將會根據(jù)這三個參數(shù)來計算新序列的元素。

zip_longest(p,q,...)：將 p、q 等序列中的元素按索引合并成元組，這些元組將作為新序列的元素。

上面這些函數(shù)的測試程序如下：

import itertools as it
# 默認(rèn)使用累加的方式計算下一個元素的值
for e in it.accumulate(range(6)):
    print(e, end=', ') # 0, 1, 3, 6, 10, 15
print('\n---------')
# 使用x*y的方式來計算迭代器下一個元素的值
for e in it.accumulate(range(1, 6), lambda x, y: x * y):
    print(e, end=', ') # 1, 2, 6, 24, 120
print('\n---------')
# 將兩個序列“鏈”在一起，生成新的迭代器
for e in it.chain(['a', 'b'], ['Kotlin', 'Swift']):
    print(e, end=', ') # 'a', 'b', 'Kotlin', 'Swift'
print('\n---------')
# 根據(jù)第二個序列來篩選第一個序列的元素，
# 由于第二個序列只有中間兩個元素為1（True），因此前一個序列只保留中間兩個元素
for e in it.compress(['a', 'b', 'Kotlin', 'Swift'], [0, 1, 1, 0]):
    print(e, end=', ') # 只有: 'b', 'Kotlin'
print('\n---------')
# 獲取序列中從長度不小于4的元素開始、到結(jié)束的所有元素
for e in it.dropwhile(lambda x:len(x)<4, ['a', 'b', 'Kotlin', 'x', 'y']):
    print(e, end=', ') # 只有: 'Kotlin', 'x', 'y'
print('\n---------')
# 去掉序列中從長度不小于4的元素開始、到結(jié)束的所有元素
for e in it.takewhile(lambda x:len(x)<4, ['a', 'b', 'Kotlin', 'x', 'y']):
    print(e, end=', ')  # 只有: 'a', 'b'
print('\n---------')
# 只保留序列中從長度不小于4的元素
for e in it.filterfalse(lambda x:len(x)<4, ['a', 'b', 'Kotlin', 'x', 'y']):
    print(e, end=', ') # 只有: 'Kotlin'
print('\n---------')
# 使用pow函數(shù)對原序列的元素進(jìn)行計算，將計算結(jié)果作為新序列的元素
for e in it.starmap(pow, [(2,5), (3,2), (10,3)]):
    print(e, end=', ') # 32, 9, 1000
print('\n---------')
# 將'ABCD'、'xy'的元素按索引合并成元組，這些元組作為新序列的元素
# 長度不夠的序列元素使用'-'字符代替
for e in it.zip_longest('ABCD', 'xy', fillvalue='-'):
    print(e, end=', ') # ('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')

運行上面程序，可以看到如下輸出結(jié)果：

0, 1, 3, 6, 10, 15,
---------
1, 2, 6, 24, 120,
---------
a, b, Kotlin, Swift,
---------
b, Kotlin,
---------
Kotlin, x, y,
---------
a, b,
---------
Kotlin,
---------
32, 9, 1000,
---------
('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-'),

在 itertools 模塊中還有一些用于生成排列組合的工具函數(shù)：

product(p, q, ...[repeat= 1)]：用序列 p 、q 、... 中的元素進(jìn)行排列組合，就相當(dāng)于使用嵌套循環(huán)組合。

permutations(p[, r])：從序列 p 中取出 r 個元素組成全排列，將排列得到的元組作為新迭代器的元素。

combinations(p, r)：從序列 p 中取出 r 個元素組成全組合，元素不允許重復(fù)，將組合得到的元組作為新迭代器的元素。

combinations with_replacement(p, r)，從序列 p 中取出 r 個元素組成全組合，元素允許重復(fù)，將組合得到的元組作為新迭代器的元素。

如下程序示范了上面 4 個函數(shù)的用法：

import itertools as it
# 使用兩個序列進(jìn)行排列組合
for e in it.product('AB', 'CD'):
    print(''.join(e), end=', ') # AC, AD, BC, BD,
print('\n---------')
# 使用一個序列、重復(fù)2次進(jìn)行全排列
for e in it.product('AB', repeat=2):
    print(''.join(e), end=', ') # AA, AB, BA, BB,
print('\n---------')
# 從序列中取2個元素進(jìn)行排列
for e in it.permutations('ABCD', 2):
    print(''.join(e), end=', ') # AB, AC, AD, BA, BC, BD, CA, CB, CD, DA, DB, DC,
print('\n---------')
# 從序列中取2個元素進(jìn)行組合、元素不允許重復(fù)
for e in it.combinations('ABCD', 2):
    print(''.join(e), end=', ') # AB, AC, AD, BC, BD, CD,
print('\n---------')
# 從序列中取2個元素進(jìn)行組合、元素允許重復(fù)
for e in it.combinations_with_replacement('ABCD', 2):
    print(''.join(e), end=', ') # AA, AB, AC, AD, BB, BC, BD, CC, CD, DD,

上面程序用到了一個字符串的 join() 方法，該方法用于將元組的所有元素連接成一個字符串。運行程序，可以看到如下輸出結(jié)果：

AC, AD, BC, BD,
---------
AA, AB, BA, BB,
---------
AB, AC, AD, BA, BC, BD, CA, CB, CD, DA, DB, DC,
---------
AB, AC, AD, BC, BD, CD,
---------
AA, AB, AC, AD, BB, BC, BD, CC, CD, DD,

看完上述內(nèi)容，你們對Python 利用itertools模塊生成迭代器有進(jìn)一步的了解嗎？如果還想了解更多知識或者相關(guān)內(nèi)容，請關(guān)注億速云行業(yè)資訊頻道，感謝大家的支持。