Cara menggunakan modul itertools dalam Python

itertools — Fungsi yang mencipta iterator untuk gelung yang cekap

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

iterable: diperlukan Iterable object untuk mengendalikan

func: Fungsi yang perlu beroperasi pada objek boleh lelar mesti mengandungi dua parameter

awal: Nilai permulaan pengumpulan

Apabila menggunakan func untuk beroperasi pada objek boleh lelar Apabila melelakan objek untuk melakukan operasi binokular, dua parameter perlu disediakan. Apa yang dikembalikan adalah iterator. Sama seperti kaedah ini adalah pengurangan di bawah kedua-dua alat pengurangan dan terkumpul adalah seperti berikut:

区别	reduce	accumulate
返回值	返回的是一个元素	返回的是一个迭代器（包含中间处理的元素）
所属模块	functools	itertools
性能	略差	比reduce好一些
初始值	可以设置初始值	可以设置初始值

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

Daripada keputusan di atas, dapat dilihat bahawa accumulate mempunyai prestasi yang lebih baik sedikit daripada reduce, dan ia juga boleh mengeluarkan proses pemprosesan pertengahan.

chain(*iterables)

iterables: Terima berbilang objek iterable

Kembalikan elemen berbilang objek iterable secara bergilir-gilir, dan kembalikan iterator, untuk elemen output kamus, kunci kamus akan dikeluarkan secara lalai

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

kombinasi(iterable: Iterable, r)

iterable: objek iterable yang perlu dikendalikan

r: the extracted jujukan Bilangan unsur

beroperasi pada objek boleh lelar dan mengembalikan jujukan mengikut bilangan jujukan yang akan diekstrak Unsur-unsur dalam jujukan juga tersusun, tidak boleh berulang dan dibentangkan dalam bentuk tupel.

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)

is similar to the above combinations(iterable: Iterable, r), but the difference is that elements of subquence of combinations_with_replacement can be repeated dan juga dipesan Butirannya adalah seperti berikut:

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: iterable object yang perlu dikendalikan

selectors: iterable untuk menentukan Objek nilai sebenar, jika ia tidak boleh str, adalah lebih baik untuk menjadi senarai, tuple, dll.

Output elemen indeks yang sepadan dalam data mengikut sama ada elemen dalam pemilih adalah benar, yang mana terpendek, dan kembalikan iterator .

from itertools import compress


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

kira(mula, langkah)

mula: elemen permulaan

langkah: saiz langkah peningkatan daripada elemen permulaan

menjana peningkatan lelaran Titik permulaan ialah permulaan dan langkah kenaikan ialah nilai yang diberikan Semua elemen tidak akan dijana serta-merta.

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: Objek boleh lelar yang perlu dikeluarkan oleh gelung

Mengembalikan lelaran yang menggelung keluar elemen objek boleh lelatif. Seperti kiraan, adalah lebih baik untuk tidak menukar hasil menjadi objek boleh lelar Kerana ia adalah gelung, adalah disyorkan untuk menggunakan next() atau gelung for untuk mendapatkan elemen.

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(predikat, iterable)

predikat: kriteria untuk sama ada hendak menggugurkan elemen

iterable: objek lelaran

dengan mengira hasil predikat Penapis mengembalikan iterator di mana elemen yang menilai kepada Benar dibuang. Tidak kira sama ada elemen berikut adalah Benar atau Salah, ia akan dikeluarkan apabila predikat adalah Salah.

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: kriteria sama ada untuk membuang elemen

iterable: objek iterable

menjana lelaran sebelum setiap satu elemen melakukan operasi, tentukan sama ada ia memenuhi syarat predikat. Sama seperti kaedah penapis, tetapi bertentangan dengan penapis.

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

Daripada keputusan di atas, dapat dilihat bahawa prestasi filterfalse dan penapis tidak jauh berbeza

groupby(iterable, key =None)

iterable: Objek boleh iterable

key: Pilihan, syarat yang perlu dinilai pada elemen, lalai ialah x == x.

Mengembalikan iterator, mengembalikan kunci dan kumpulan berturut-turut mengikut kunci (elemen berterusan yang memenuhi syarat kunci).

Perhatikan bahawa anda perlu mengisihnya sebelum menggunakan kumpulan mengikut kumpulan.

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: objek iterable yang perlu dikendalikan

start: to mulakan operasi Kedudukan indeks

berhenti: Kedudukan indeks untuk menamatkan operasi

langkah: Saiz langkah

Mengembalikan lelaran. Sama seperti menghiris, tetapi indeksnya tidak menyokong nombor negatif.

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]

Seperti yang dapat dilihat daripada keputusan di atas, prestasi penghirisan adalah lebih baik sedikit daripada prestasi islice.

berpasangan(boleh diulang)

Objek boleh lelar yang perlu dikendalikan

Mengembalikan lelaran, yang mengembalikan pasangan bertindih berturut-turut dalam objek boleh lelar , ia kembali kosong.

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)]

permutasi(iterable, r=None)

iterable: objek lelaran yang perlu dikendalikan

r: turutan yang diekstrak

adalah serupa dengan gabungan , kedua-dua mengekstrak urutan objek boleh lelar Walau bagaimanapun, pilih atur tidak boleh berulang dan tidak tertib, hanya bertentangan dengan kombinasi_dengan_penggantian.

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'))

produk(*iterables, repeat=1)

iterables: objek boleh lelaran, yang boleh berbilang

ulang: bilangan ulangan objek boleh lelaran, yang ialah, menyalin Bilangan kali

mengembalikan iterator. Pilih atur dan gabungan analog menjana objek boleh lelar produk Cartes. Fungsi produk adalah serupa dengan fungsi zip, tetapi sementara zip memadankan elemen satu dengan satu, produk mencipta hubungan satu dengan banyak..

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)]

ulang(objek[, kali])

objek: sebarang objek undang-undang

kali: pilihan, bilangan kali objek objek dijana, apabila masa tidak diluluskan, kemudian gelung Infinite

mengembalikan lelaran yang berulang kali menjana objek objek berdasarkan masa.

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: function of skop iterator object element

iterable: iterable object

mengembalikan iterator , gunakan fungsi kepada semua elemen objek boleh lelar (semua elemen mestilah objek boleh lelar, walaupun hanya terdapat satu nilai, ia perlu dibalut dengan objek boleh lelawar, seperti tuple (1, )), serupa dengan fungsi peta apabila fungsi Apabila parameter konsisten dengan elemen objek boleh lelar, gunakan tupel dan bukannya elemen, seperti pow(a, b), yang sepadan dengan [(2,3), (3,3)].

Perbezaan antara peta dan peta bintang ialah peta biasanya beroperasi apabila fungsi hanya mempunyai satu parameter, manakala peta bintang boleh beroperasi apabila fungsi mempunyai berbilang parameter.

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: &#39;int&#39; 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)

依次输出迭代器中的元素，不会循环输出，有多少输出多少。当输出字典元素时，默认会输出字典的键；而对于列表，则相当于使用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)

类似于filter方法，返回所有满足predicate条件的元素，作为一个可迭代对象。

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是取最长的，缺少的使用缺省值。

Atas ialah kandungan terperinci Cara menggunakan modul itertools dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!