Python中itertools模塊如何使用

這篇文章主要介紹“Python中itertools模塊如何使用”，在日常操作中，相信很多人在Python中itertools模塊如何使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Python中itertools模塊如何使用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

itertools — 為高效循環而創建迭代器的函數

accumulate(iterable: Iterable, func: None, initial:None)

iterable：需要操作的可迭代對象

func：對可迭代對象需要操作的函數，必須包含兩個參數

initial: 累加的開始值

對可迭代對象進行累計或者通過func實現雙目運算，當指定func的時候需要兩個參數。返回的是迭代器，與這個方法類似的就是functools下的reduce，reduce和accumulate都是累計進行操作，不同的是reduce只會返回最后的元素，而accumulate會顯示所有的元素，包含中間的元素，對比如下：

import time
from itertools import accumulate
from functools import reduce

l_data = [1, 2, 3, 4]
data = accumulate(l_data, lambda x, y: x + y, initial=2)
print(list(data))
start = time.time()
for i in range(100000):
    data = accumulate(l_data, lambda x, y: x + y, initial=2)
print(time.time() - start)
start = time.time()
for i in range(100000):
    data = reduce(lambda x, y: x + y, l_data)
print(time.time() - start)
#輸出
[2, 3, 5, 8, 12]
0.027924537658691406
0.03989362716674805

由上述結果可知，accumulate比reduce性能稍好一些，而且還能輸出中間的處理過程。

chain(*iterables)

iterables:接收多個可迭代對象

依次返回多個迭代對象的元素，返回的是一個迭代器,對于字典輸出元素時，默認會輸出字典的key

from itertools import chain
import time

list_data = [1, 2, 3]
dict_data = {"a": 1, "b": 2}
set_data = {4, 5, 6}
print(list(chain(list_data, dict_data, set_data)))

list_data = [1, 2, 3]
list_data2 = [4, 5, 6]

start = time.time()
for i in range(100000):
    chain(list_data, list_data2)
print(time.time() - start)

start = time.time()
for i in range(100000):
    list_data.extend(list_data2)
print(time.time() - start)
#輸出
[1, 2, 3, 'a', 'b', 4, 5, 6]
0.012955427169799805
0.013965129852294922

combinations(iterable: Iterable, r)

iterable:需要操作的可迭代對象

r: 抽取的子序列元素的個數

操作可迭代對象，根據所需抽取的子序列個數返回子序列，子序列中的元素也是有序、不可重復并且是以元組的形式呈現的。

from itertools import combinations


data = range(5)
print(tuple(combinations(data, 2)))
str_data = "asdfgh"
print(tuple(combinations(str_data, 2)))
#輸出
((0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4))
(('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'g'), ('f', 'h'), ('g', 'h'))

combinations_with_replacement(iterable: Iterable, r)

與上述的combinations(iterable: Iterable, r)類似，不過區別在于，combinations_with_replacement的子序列的元素可以重復，也是有序的，具體如下：

from itertools import combinations_with_replacement


data = range(5)
print(tuple(combinations_with_replacement(data, 2)))
str_data = "asdfgh"
print(tuple(combinations_with_replacement(str_data, 2)))
#輸出
((0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4))
(('a', 'a'), ('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 's'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'd'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'f'), ('f', 'g'), ('f', 'h'), ('g', 'g'), ('g', 'h'), ('h', 'h'))

compress(data: Iterable, selectors: Iterable)

data:需要操作的可迭代對象

selectors:判斷真值的可迭代對象，不能時str，最好是列表、元組、之類的

根據selectors中的元素是否為true來輸出data中對應索引的元素，以最短的為準，返回一個迭代器。

from itertools import compress


data = "asdfg"
list_data = [1, 0, 0, 0, 1, 4]
print(list(compress(data, list_data)))
#輸出
['a', 'g']

count(start, step)

start: 開始的元素

step: 自開始元素增長的步長

返回一個迭代器，從start按照步長遞增，不會一次性生成，最好使用next()進行元素的遞歸的獲取。

from itertools import count


c = count(start=10, step=20)
print(next(c))
print(next(c))
print(next(c))
print(next(c))
print(c)
#輸出
10
30
50
70
count(90, 20)

cycle(iterable)

iterable： 需要循環輸出的可迭代對象

返回一個迭代器，循環輸出可迭代對象的元素。于count一樣，最好不要將結果轉換為可迭代對象，因為是循環，所以建議使用next()或者for循環獲取元素。

from itertools import cycle

a = "asdfg"
data = cycle(a)
print(next(data))
print(next(data))
print(next(data))
print(next(data))
#輸出
a
s
d
f

dropwhile(predicate, iterable)

predicate:是否舍棄元素的標準

iterable: 可迭代對象

返回一個迭代器,根據predicate是否為True來舍棄元素。當predicate為False時，后面的元素不管是否為True都會輸出。

from itertools import dropwhile


list_data = [1, 2, 3, 4, 5]
print(list(dropwhile(lambda i: i < 3, list_data)))
print(list(dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1])))
#輸出
[3, 4, 5]
[6, 4, 1]

filterfalse(predicate, iterable)

predicate:是否舍棄元素的標準

iterable: 可迭代對象

返回一個迭代器, 根據predicate是否為False判斷輸出，對所有元素進行操作。類似于filter方法，但是是filter的相反的.

import time
from itertools import filterfalse

print(list(filterfalse(lambda i: i % 2 == 0, range(10))))

start = time.time()
for i in range(100000):
    filterfalse(lambda i: i % 2 == 0, range(10))
print(time.time() - start)

start = time.time()
for i in range(100000):
    filter(lambda i: i % 2 == 0, range(10))
print(time.time() - start)
#輸出
[1, 3, 5, 7, 9]
0.276653528213501
0.2768676280975342

由上述結果看出，filterfalse與filter性能相差不大

groupby(iterable, key=None)

iterable: 可迭代對象

key: 可選，需要對元素進行判斷的條件, 默認為x == x。

返回一個迭代器,根據key返回連續的鍵和組（連續符合key條件的元素）。

注意使用groupby進行分組前需要對其進行排序。

from itertools import groupby


str_data = "babada"
for k, v in groupby(str_data):
    print(k, list(v))


str_data = "aaabbbcd"
for k, v in groupby(str_data):
    print(k, list(v))


def func(x: str):
    print(x)
    return x.isdigit()


str_data = "12a34d5"
for k, v in groupby(str_data, key=func):
    print(k, list(v))
#輸出
b ['b']
a ['a']
b ['b']
a ['a']
d ['d']
a ['a']
a ['a', 'a', 'a']
b ['b', 'b', 'b']
c ['c']
d ['d']
1
2
a
True ['1', '2']
3
False ['a']
4
d
True ['3', '4']
5
False ['d']
True ['5']

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

iterable: 需要操作的可迭代對象

start： 開始操作的索引位置

stop: 結束操作的索引位置

step: 步長

返回一個迭代器。類似于切片，但是其索引不支持負數。

from itertools import islice
import time

list_data = [1, 5, 4, 2, 7]
#學習中遇到問題沒人解答？小編創建了一個Python學習交流群：725638078

start = time.time()
for i in range(100000):
    data = list_data[:2:]

print(time.time() - start)
start = time.time()
for i in range(100000):
    data = islice(list_data, 2)
print(time.time() - start)
print(list(islice(list_data, 1, 3)))
print(list(islice(list_data, 1, 4, 2)))
#輸出
0.010963201522827148
0.01595783233642578
[5, 4]
[5, 2]

0.010963201522827148
0.01595783233642578
[5, 4]
[5, 2]

由上述結果可以看出，切片性能比islice性能稍好一些。

pairwise(iterable)

需要操作的可迭代對象

返回一個迭代器, 返回可迭代對象中的連續重疊對，少于兩個返回空。

from itertools import pairwise

str_data = "asdfweffva"
list_data = [1, 2, 5, 76, 8]
print(list(pairwise(str_data)))
print(list(pairwise(list_data)))
#輸出
[('a', 's'), ('s', 'd'), ('d', 'f'), ('f', 'w'), ('w', 'e'), ('e', 'f'), ('f', 'f'), ('f', 'v'), ('v', 'a')]
[(1, 2), (2, 5), (5, 76), (76, 8)]

permutations(iterable, r=None)

iterable： 需要操作的可迭代對象

r: 抽取的子序列

與combinations類似，都是抽取可迭代對象的子序列，不過，permutations是不可重復,無序的， 與combinations_with_replacement剛好相反。

from itertools import permutations


data = range(5)
print(tuple(permutations(data, 2)))
str_data = "asdfgh"
print(tuple(permutations(str_data, 2)))
#輸出
((0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3))
(('a', 's'), ('a', 'd'), ('a', 'f'), ('a', 'g'), ('a', 'h'), ('s', 'a'), ('s', 'd'), ('s', 'f'), ('s', 'g'), ('s', 'h'), ('d', 'a'), ('d', 's'), ('d', 'f'), ('d', 'g'), ('d', 'h'), ('f', 'a'), ('f', 's'), ('f', 'd'), ('f', 'g'), ('f', 'h'), ('g', 'a'), ('g', 's'), ('g', 'd'), ('g', 'f'), ('g', 'h'), ('h', 'a'), ('h', 's'), ('h', 'd'), ('h', 'f'), ('h', 'g'))

product(*iterables, repeat=1)

iterables: 可迭代對象，可以為多個

repeat: 可迭代對象的重復次數，也就是復制的次數

返回迭代器。生成可迭代對象的笛卡爾積, 類似于兩個或多個可迭代對象的排列組合。與zip函數很像，但是zip是元素的一對一對應關系，而product則是一對多的關系。

from itertools import product


list_data = [1, 2, 3]
list_data2 = [4, 5, 6]
print(list(product(list_data, list_data2)))
print(list(zip(list_data, list_data2)))

# 如下兩個含義是一樣的，都是將可迭代對象復制一份， 很方便的進行同列表的操作
print(list(product(list_data, repeat=2)))
print(list(product(list_data, list_data)))
# 同上述含義
print(list(product(list_data, list_data2, repeat=2)))
print(list(product(list_data, list_data2, list_data, list_data2)))
#輸出
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
[(1, 4, 1, 4), (1, 4, 1, 5), (1, 4, 1, 6), (1, 4, 2, 4), (1, 4, 2, 5), (1, 4, 2, 6), (1, 4, 3, 4), (1, 4, 3, 5), (1, 4, 3, 6), (1, 5, 1, 4), (1, 5, 1, 5), (1, 5, 1, 6), (1, 5, 2, 4), (1, 5, 2, 5), (1, 5, 2, 6), (1, 5, 3, 4), (1, 5, 3, 5), (1, 5, 3, 6), (1, 6, 1, 4), (1, 6, 1, 5), (1, 6, 1, 6), (1, 6, 2, 4), (1, 6, 2, 5), (1, 6, 2, 6), (1, 6, 3, 4), (1, 6, 3, 5), (1, 6, 3, 6), (2, 4, 1, 4), (2, 4, 1, 5), (2, 4, 1, 6), (2, 4, 2, 4), (2, 4, 2, 5), (2, 4, 2, 6), (2, 4, 3, 4), (2, 4, 3, 5), (2, 4, 3, 6), (2, 5, 1, 4), (2, 5, 1, 5), (2, 5, 1, 6), (2, 5, 2, 4), (2, 5, 2, 5), (2, 5, 2, 6), (2, 5, 3, 4), (2, 5, 3, 5), (2, 5, 3, 6), (2, 6, 1, 4), (2, 6, 1, 5), (2, 6, 1, 6), (2, 6, 2, 4), (2, 6, 2, 5), (2, 6, 2, 6), (2, 6, 3, 4), (2, 6, 3, 5), (2, 6, 3, 6), (3, 4, 1, 4), (3, 4, 1, 5), (3, 4, 1, 6), (3, 4, 2, 4), (3, 4, 2, 5), (3, 4, 2, 6), (3, 4, 3, 4), (3, 4, 3, 5), (3, 4, 3, 6), (3, 5, 1, 4), (3, 5, 1, 5), (3, 5, 1, 6), (3, 5, 2, 4), (3, 5, 2, 5), (3, 5, 2, 6), (3, 5, 3, 4), (3, 5, 3, 5), (3, 5, 3, 6), (3, 6, 1, 4), (3, 6, 1, 5), (3, 6, 1, 6), (3, 6, 2, 4), (3, 6, 2, 5), (3, 6, 2, 6), (3, 6, 3, 4), (3, 6, 3, 5), (3, 6, 3, 6)]
[(1, 4, 1, 4), (1, 4, 1, 5), (1, 4, 1, 6), (1, 4, 2, 4), (1, 4, 2, 5), (1, 4, 2, 6), (1, 4, 3, 4), (1, 4, 3, 5), (1, 4, 3, 6), (1, 5, 1, 4), (1, 5, 1, 5), (1, 5, 1, 6), (1, 5, 2, 4), (1, 5, 2, 5), (1, 5, 2, 6), (1, 5, 3, 4), (1, 5, 3, 5), (1, 5, 3, 6), (1, 6, 1, 4), (1, 6, 1, 5), (1, 6, 1, 6), (1, 6, 2, 4), (1, 6, 2, 5), (1, 6, 2, 6), (1, 6, 3, 4), (1, 6, 3, 5), (1, 6, 3, 6), (2, 4, 1, 4), (2, 4, 1, 5), (2, 4, 1, 6), (2, 4, 2, 4), (2, 4, 2, 5), (2, 4, 2, 6), (2, 4, 3, 4), (2, 4, 3, 5), (2, 4, 3, 6), (2, 5, 1, 4), (2, 5, 1, 5), (2, 5, 1, 6), (2, 5, 2, 4), (2, 5, 2, 5), (2, 5, 2, 6), (2, 5, 3, 4), (2, 5, 3, 5), (2, 5, 3, 6), (2, 6, 1, 4), (2, 6, 1, 5), (2, 6, 1, 6), (2, 6, 2, 4), (2, 6, 2, 5), (2, 6, 2, 6), (2, 6, 3, 4), (2, 6, 3, 5), (2, 6, 3, 6), (3, 4, 1, 4), (3, 4, 1, 5), (3, 4, 1, 6), (3, 4, 2, 4), (3, 4, 2, 5), (3, 4, 2, 6), (3, 4, 3, 4), (3, 4, 3, 5), (3, 4, 3, 6), (3, 5, 1, 4), (3, 5, 1, 5), (3, 5, 1, 6), (3, 5, 2, 4), (3, 5, 2, 5), (3, 5, 2, 6), (3, 5, 3, 4), (3, 5, 3, 5), (3, 5, 3, 6), (3, 6, 1, 4), (3, 6, 1, 5), (3, 6, 1, 6), (3, 6, 2, 4), (3, 6, 2, 5), (3, 6, 2, 6), (3, 6, 3, 4), (3, 6, 3, 5), (3, 6, 3, 6)]

repeat(object[, times])

object：任意合法對象

times: 可選，object對象生成的次數, 當不傳入times，則無限循環

返回一個迭代器，根據times重復生成object對象。

from itertools import repeat


str_data = "assd"
print(repeat(str_data))
print(list(repeat(str_data, 4)))


list_data = [1, 2, 4]
print(repeat(list_data))
print(list(repeat(list_data, 4)))

dict_data = {"a": 1, "b": 2}
print(repeat(dict_data))
print(list(repeat(dict_data, 4)))
#輸出
repeat('assd')
['assd', 'assd', 'assd', 'assd']
repeat([1, 2, 4])
[[1, 2, 4], [1, 2, 4], [1, 2, 4], [1, 2, 4]]
repeat({'a': 1, 'b': 2})
[{'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 2}]

starmap(function, iterable)

function: 作用域迭代器對象元素的函數

iterable: 可迭代對象

返回一個迭代器, 將函數作用與可迭代對象的所有元素（所有元素必須要是可迭代對象，即使只有一個值，也需要使用可迭代對象包裹，例如元組(1, )）中,與map函數類似；當function參數與可迭代對象元素一致時，使用元組代替元素，例如pow(a, b)，對應的是[(2,3), (3,3)]。

map與starmap的區別在于，map我們一般會操作一個function只有一個參數的情況，starmap可以操作function多個參數的情況。

from itertools import starmap


list_data = [1, 2, 3, 4, 5]
list_data2 = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
list_data3 = [(1,), (2,), (3,), (4,), (5,)]

print(list(starmap(lambda x, y: x + y, list_data2)))
print(list(map(lambda x: x * x, list_data)))
print(list(starmap(lambda x: x * x, list_data)))
print(list(starmap(lambda x: x * x, list_data3)))
#輸出
[2, 4, 6, 8, 10]
[1, 4, 9, 16, 25]
Traceback (most recent call last):
  File "c:\Users\ts\Desktop\2022.7\2022.7.22\test.py", line 65, in <module>
    print(list(starmap(lambda x: x * x, list_data)))
TypeError: 'int' object is not iterable

takewhile(predicate, iterable)

predicate：判斷條件，為真就返回

iterable: 可迭代對象

當predicate為真時返回元素，需要注意的是，當第一個元素不為True時，則后面的無論結果如何都不會返回，找的前多少個為True的元素。

from itertools import takewhile
#學習中遇到問題沒人解答？小編創建了一個Python學習交流群：725638078

list_data = [1, 5, 4, 6, 2, 3]
print(list(takewhile(lambda x: x > 0, list_data)))
print(list(takewhile(lambda x: x > 1, list_data)))

zip_longest(*iterables, fillvalue=None)

iterables：可迭代對象

fillvalue：當長度超過時，缺省值、默認值， 默認為None

返回迭代器, 可迭代對象元素一一對應生成元組，當兩個可迭代對象長度不一致時，會按照最長的有元素輸出并使用fillvalue補充，是zip的反向擴展，zip為最小長度輸出。

from itertools import zip_longest

list_data = [1, 2, 3]
list_data2 = ["a", "b", "c", "d"]
print(list(zip_longest(list_data, list_data2, fillvalue="-")))
print(list(zip_longest(list_data, list_data2)))
print(list(zip(list_data, list_data2)))

[(1, 'a'), (2, 'b'), (3, 'c'), ('-', 'd')]
[(1, 'a'), (2, 'b'), (3, 'c'), (None, 'd')]
[(1, 'a'), (2, 'b'), (3, 'c')]

總結

accumulate(iterable: Iterable, func: None, initial:None)：

進行可迭代對象元素的累計運算，可以設置初始值，類似于reduce，相比較reduce,accumulate可以輸出中間過程的值，reduce只能輸出最后結果，且accumulate性能略好于reduce。

chain(*iterables)

依次輸出迭代器中的元素，不會循環輸出，有多少輸出多少。對于字典輸出元素時，默認會輸出字典的key；對于列表來說相當于是extend。

combinations(iterable: Iterable, r)：

抽取可迭代對象的子序列，其實就是排列組合，不過只返回有序、不重復的子序列，以元組形式呈現。

combinations_with_replacement(iterable: Iterable, r)

抽取可迭代對象的子序列，與combinations類似，不過返回無序、不重復的子序列，以元組形式呈現。

compress(data: Iterable, selectors: Iterable)

根據selectors中的元素是否為True或者False返回可迭代對象的合法元素，selectors為str時，都為True，并且只會決定長度。

count(start, step)：

從start開始安裝step不斷生成元素，是無限循環的，最好控制輸出個數或者使用next(),send()等獲取、設置結果

cycle(iterable)

依次輸出可迭代對象的元素，是無限循環的，相當于是chain的循環。最好控制輸出個數或者使用next(),send()等獲取、設置結果。

dropwhile(predicate, iterable)

根據predicate是否為False來返回可迭代器元素，predicate可以為函數， 返回的是第一個False及之后的所有元素，不管后面的元素是否為True或者False。適用于需要舍棄迭代器或者可迭代對象的前面一部分內容，例如在寫入文件時忽略文檔注釋

filterfalse(predicate, iterable)

依據predicate返回可迭代對象的所有predicate為True的元素，類似于filter方法。

groupby(iterable, key=None)

輸出連續符合key要求的鍵值對，默認為x == x。

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

對可迭代對象進行切片，和普通切片類似，但是這個不支持負數。適用于可迭代對象內容的切割，例如你需要獲取一個文件中的某幾行的內容

pairwise(iterable)

返回連續的重疊對象（兩個元素）， 少于兩個元素返回空，不返回。

permutations(iterable, r=None)

從可迭代對象中抽取子序列，與combinations類似，不過抽取的子序列是無序、可重復。

product(*iterables, repeat=1)

輸出可迭代對象的笛卡爾積，類似于排序組合，不可重復,是兩個或者多個可迭代對象進行操作，當是一個可迭代對象時，則返回元素，以元組形式返回。

repeat(object[, times])

重復返回object對象，默認時無限循環

starmap(function, iterable)

批量操作可迭代對象中的元素，操作的可迭代對象中的元素必須也要是可迭代對象，與map類似，但是可以對類似于多元素的元組進行操作。

takewhile(predicate, iterable)

返回前多少個predicate為True的元素，如果第一個為False，則直接輸出一個空。

zip_longest(*iterables, fillvalue=None)

將可迭代對象中的元素一一對應，組成元組形式存儲，與zip方法類似，不過zip是取最短的，而zip_longest是取最長的，缺少的使用缺省值。

到此，關于“Python中itertools模塊如何使用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！