Podle dokumentace Pythonu je Itertools modul Pythonu, který poskytuje sadu rychlých a paměťově efektivních nástrojů pro práci s iterátory Pythonu. Tyto nástroje lze používat samostatně nebo v kombinaci a umožňují stručně a efektivně vytvářet iterátory a pracovat s nimi rychlým a paměťově efektivním způsobem.
Modul Itertools obsahuje funkce, které usnadňují práci s iterátory, zejména při práci s velkými sadami dat. Funkce Itertools mohou pracovat na existujících iterátorech a vytvářet ještě složitější iterátory Pythonu.
Kromě toho mohou Itertools pomoci vývojářům snížit chyby při práci s iterátory a psát čistší, čitelný a udržovatelný kód.
Na základě funkčnosti, kterou poskytují iterátory v modulu Itertools, je lze rozdělit do následujících typů:
Table of Contents
#1. Nekonečné iterátory
Jedná se o iterátory, které vám umožňují pracovat s nekonečnými sekvencemi a spouštět smyčku donekonečna, pokud není zadána žádná podmínka, která by smyčku opustila. Takové iterátory jsou užitečné při simulaci nekonečných smyček nebo při generování neomezené sekvence. Itertools má tři nekonečné iterátory, mezi které patří count(), cycle() a repeat().
#2. Kombinatorické iterátory
Kombinatorické iterátory obsahují funkce, které lze použít k práci na kartézských součinech a provádění kombinací a permutací prvků obsažených v iterovatelné. Toto jsou hlavní funkce, když se snažíte najít všechny možné způsoby, jak uspořádat nebo zkombinovat prvky v iterovatelné. Itertools má čtyři kombinatorické iterátory. Jsou to product(), permutations(), combinations() a combinations_with_replacement().
#3. Iterátory končící na nejkratší vstupní sekvenci
Jedná se o ukončovací iterátory, které se používají na konečných sekvencích a generují výstup na základě typu použité funkce. Příklady těchto ukončovacích iterátorů zahrnují: akumulovat(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile (), tee() a zip_longest().
Podívejme se, jak fungují různé funkce Itertools podle jejich typu:
Nekonečné iterátory
Mezi tři nekonečné iterátory patří:
#1. počet()
Funkce count(start, step) generuje nekonečnou sekvenci čísel počínaje počáteční hodnotou. Funkce má dva volitelné argumenty: start a krok. Argument start nastavuje, kde má posloupnost čísel začínat. Ve výchozím nastavení začíná na 0, pokud není zadána počáteční hodnota. krok nastavuje rozdíl mezi každým po sobě jdoucím číslem. Výchozí hodnota kroku je 1.
import itertools
# count starting at 4, making steps of 2
for i in itertools.count(4, 2):
# condition to end the loop avoiding infinite looping
if i == 14:
break
else:
print(i) # output - 4, 6, 8, 10, 12
Výstup
4 6 8 10 12
#2. cyklus()
Funkce cycle(iterable) bere iterovatelný jako argument a poté cyklicky prochází iterovatelným a umožňuje přístup k položkám v iterovatelném pořadí v pořadí, v jakém se objevují.
Například když projdeme dovnitř [“red”, “green”, “yellow”] do cycle(), v prvním cyklu budeme mít přístup k „červené“; ve druhém cyklu budeme mít přístup k „zelené“, poté „žluté“. Ve čtvrtém cyklu, protože všechny prvky byly v iterovatelném cyklu vyčerpány, začneme znovu na „červené“ a pak budeme pokračovat donekonečna.
Při volání cycle() uložíte jeho výsledek do proměnné, abyste vytvořili iterátor, který zachová svůj stav. Tím je zajištěno, že cyklus nezačíná pokaždé znovu, takže máte přístup pouze k prvnímu prvku.
import itertools
colors = ["red", "green", "yellow"]
# pass in colors into cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)
# range used to stop the infinite loop once we've printed 7 times
# next() used to return the next item from the iterator
for i in range(7):
print(next(color_cycle))
Výstup:
red green yellow red green yellow red
#3. opakovat()
repeat(elem,n) má dva argumenty, prvek k opakování (elem) a kolikrát chcete prvek(n) opakovat. Prvek, který chcete opakovat, může být jedna hodnota nebo iterovatelný. Pokud nezadáte n, prvek se bude nekonečně opakovat.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Výstup:
10 10 10
Kombinatorické iterátory
Mezi kombinatorické iterátory patří:
#1. produkt()
product() je funkce používaná k výpočtu kartézského součinu iterovatelného prvku, který je jí předán. Pokud máme dvě iterovatelné nebo množiny, například x = {7,8} a y = {1,2,3}, kartézský součin x a y bude obsahovat všechny možné kombinace prvků z x a y, kde první prvek je z x a druhý z y. Kartézský součin x a y v tomto případě je [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() přebírá volitelný parametr zvaný repeat, který se používá k výpočtu kartézského součinu iterovatelného se sebou samým. repeat určuje počet opakování pro každý prvek ze vstupních iterable při výpočtu kartézského součinu.
Volání produktu (‚ABCD‘, repeat=2) například poskytuje kombinace jako (‚A‘, ‚A‘), (‚A‘, ‚B‘), (‚A‘, ‚C‘) atd. na. Pokud by bylo opakování nastaveno na 3, funkce by poskytla kombinace jako (‚A‘, ‚A‘, ‚A‘), (‚A‘, ‚A‘, ‚B‘), (‚A‘, ‚A‘ , ‚C‘), (‚A‘, ‚A‘, ‚D‘) a tak dále.
from itertools import product
# product() with the optional repeat argument
print("product() with the optional repeat argument ")
print(list(product('ABC', repeat = 2)))
# product with no repeat
print("product() WITHOUT an optional repeat argument")
print(list(product([7,8], [1,2,3])))
Výstup
product() with the optional repeat argument
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() WITHOUT an optional repeat argument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]
#2. permutace()
permutations(iterable, group_size) vrátí všechny možné permutace iterovatelného prvku, který mu byl předán. Permutace představuje počet způsobů, jak lze prvky v sadě seřadit. permutations() má volitelný argument group_size. Pokud není zadán group_size, vygenerované permutace budou mít stejnou velikost jako délka iterovatelného předávaného do funkce.
import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))
print("Permutations with a size of 2")
print(sized_permutations)
print("Permutations with NO size argument")
print(unsized_permuatations)
Výstup
Permutations with a group size of 2 [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)] Permutations with NO size argument [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
#3. kombinace()
combinations(iterable, size) vrací všechny možné kombinace iterovatelného prvku dané délky z prvků v iterovateli předávaných do funkce. Argument velikost určuje velikost každé kombinace.
Výsledky jsou seřazeny. Kombinace se mírně liší od permutací. U permutace na pořadí záleží, ale u kombinace na pořadí nezáleží. Například v [A, B, C] existuje 6 permutací: AB, AC, BA, BC, CA, CB, ale pouze 3 kombinace AB, AC, BC.
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations(numbers,2))
size3_combination = list(itertools.combinations(numbers, 3))
print("Combinations with a size of 2")
print(size2_combination)
print("Combinations with a size of 3")
print(size3_combination)
Výstup:
Combinations with a size of 2 [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)] Combinations with a size of 3 [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
#4. combinations_with_replacement()
combinations_with_replacement(iterovatelný, velikost) generuje všechny možné kombinace iterovatelného prvku dané délky z iterovatelného prvku předaného do funkce a umožňuje opakované prvky ve výstupních kombinacích. Velikost určuje velikost generovaných kombinací.
Tato funkce se liší od combinations() v tom, že poskytuje kombinace, kde se prvek může opakovat více než jednou. Můžete například získat kombinaci, jako je (1,1), kterou nemůžete pomocí kombinace().
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinations_with_replacement => size 2")
print(size2_combination)
Výstup
Combinations_with_replacement => size 2 [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
Ukončení iterátorů
To zahrnuje iterátory, jako jsou:
#1. akumulovat()
akumulovat(iterovatelný, funkce) má iterovatelný a druhý volitelný argument, kterým je funkce. Potom vrátí akumulovaný výsledek aplikace funkce v každé iteraci na prvky v iterovatelném prvku. Pokud není předána žádná funkce, provede se sčítání a vrátí se akumulované výsledky.
import itertools
import operator
numbers = [1, 2, 3, 4, 5]
# Accumulate the sum of numbers
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumulate with no function")
print(list(accumulated_val))
print("Accumulate with multiplication")
print(list(accumulated_mul))
Výstup:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. řetěz()
chain(iterable_1, iterable_2, …) vezme několik iterovatelných položek a zřetězí je dohromady a vytvoří jednu iterovatelnou obsahující hodnoty z iterovatelných položek předávaných funkci chain()
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] # Chain letters and numbers together chained_iterable = list(itertools.chain(letters, numbers, colors)) print(chained_iterable)
Výstup:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) tato funkce je podobná funkci chain(). Liší se však od řetězce tím, že bere pouze jeden iterovatel obsahující dílčí iterable a spojuje je dohromady.
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] iterable = ['hello',colors, letters, numbers] chain = list(itertools.chain.from_iterable(iterable)) print(chain)
Výstup:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. komprimovat()
Komprimovat(data, selektory) přijímá dva argumenty, data, která jsou iterovatelná, a selektory, což je iterovatelnost, která obsahuje booleovské hodnoty true a false. 1, 0 lze také použít jako alternativy k booleovským hodnotám true a false. compress() pak filtruje předaná data pomocí odpovídajících prvků předávaných v selektoru.
Hodnoty v datech, které odpovídají hodnotě true nebo 1 ve voliči, jsou vybrány, zatímco ostatní, které odpovídají hodnotě false nebo 0, jsou ignorovány. Pokud v selektorech předáte méně booleanů, než je počet položek v datech, všechny prvky za předanými logickými hodnotami v selektorech se ignorují
import itertools # data has 10 items data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] # passing in 9 selector items selectors = [True, False, 1, False, 0, 1, True, False, 1] # Select elements from data based on selectors filtered_data = list(itertools.compress(data, selectors)) print(filtered_data)
Výstup:
['A', 'C', 'F', 'G', 'I']
#5. drop while()
dropwhile(funkce, sekvence) přebírá funkci s podmínkou, která vrací true nebo false a posloupnost hodnot. Poté zruší všechny hodnoty, dokud splněná podmínka nevrátí hodnotu False. Jakmile podmínka vrátí hodnotu false, zbytek prvků bude zahrnut do jejích výsledků bez ohledu na to, zda vrátí hodnotu True nebo False.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Výstup:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filterfalse()
filterfalse(funkce, sekvence) přijímá funkci s podmínkou, která se vyhodnotí jako true nebo false, a sekvencí. Potom vrátí hodnoty z posloupnosti, které nesplňují podmínku ve funkci.
import itertools numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3] # Filter elements for which condition is False filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers)) print(filtered_numbers)
Výstup:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. skupina vytvořená()
groupby(iterable, key) vezme iterovatelný a klíč, pak vytvoří iterátor, který vrátí po sobě jdoucí klíče a skupiny. Aby to fungovalo, iterovatelný prvek, který je mu předán, musí být seřazen podle stejné klíčové funkce. Funkce klíče počítá klíčovou hodnotu pro každý prvek v iterovatelné.
import itertools
input_list = [("Domestic", "Cow"), ("Domestic", "Dog"), ("Domestic", "Cat"),("Wild", "Lion"), ("Wild", "Zebra"), ("Wild", "Elephant")]
classification = itertools.groupby(input_list,lambda x: x[0])
for key,value in classification:
print(key,":",list(value))
Výstup:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice(iterovatelný, start, stop, krok) umožňuje rozdělit iterovatelný segment pomocí předaných hodnot start, stop a step. Argument kroku je volitelný. Počítání začíná od 0 a položka na čísle zastávky není zahrnuta.
import itertools
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
# Select elements within a range
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice without setting a step value")
print(selected_numbers)
print("islice with a step value of 2")
print(selected_numbers_step)
Výstup:
islice without setting a step value [3, 4, 5, 6, 7, 8, 9, 10] islice with a step value of 2 [3, 5, 7, 9]
#9. pairwise()
pairwise(iterable) vrací po sobě jdoucí překrývající se páry převzaté z iterovatelné položky v pořadí, v jakém se objevují v iterovatelné. Pokud má předaná iterovatelná hodnota méně než dvě hodnoty, bude výsledek z pairwise() prázdný.
from itertools import pairwise numbers = [1, 2, 3, 4, 5, 6, 7, 8] word = 'WORLD' single = ['A'] print(list(pairwise(numbers))) print(list(pairwise(word))) print(list(pairwise(single)))
Výstup:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. hvězdná mapa()
starmap(funkce, iterovatelná) je funkce používaná namísto map(), když jsou parametry argumentů již seskupeny do n-tic. startmap() aplikuje funkci na prvky iterovatelného prvku, který je mu předán. Iterovatelný by měl mít prvky seskupené do n-tic.
import itertools iter_starmap = [(123, 63, 13), (5, 6, 52), (824, 51, 9), (26, 24, 16), (14, 15, 11)] print (list(itertools.starmap(min, iter_starmap)))
Výstup:
[13, 5, 9, 16, 11]
#11. trvat ()
takewhile(funkce, iterovatelné) funguje opačně než dropwhile(). takewhile() přijímá funkci s podmínkou, která má být vyhodnocena, a iterovatelnou. Poté zahrnuje všechny prvky v iterovatelném prvku, které splňují podmínku ve funkci, dokud není vrácena hodnota False. Jakmile je vrácena hodnota False, všechny následující prvky v iterovatelném prvku jsou ignorovány.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Výstup:
[1, 2, 3, 4]
#12. tričko()
tee(iterable, n) vezme iterovatelný a vrátí několik nezávislých iterátorů. Počet iterátorů, které se mají vrátit, je nastaven pomocí n, což je ve výchozím nastavení 2.
import itertools numbers = [1, 2, 3, 4, 5] # Create two independent iterators from numbers iter1, iter2 = itertools.tee(numbers, 2) print(list(iter1)) print(list(iter2))
Výstup:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) přijímá několik iterátorů a fillvalue. Poté vrátí iterátor, který agreguje prvky z každého z iterátorů, které mu byly předány. Pokud iterátory nemají stejnou délku, jsou chybějící hodnoty nahrazeny fillvalue předanou funkci, dokud není vyčerpána nejdelší iterovatelná.
import itertools
names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]
# Combine name and ages, filling in missing ages with a dash
combined = itertools.zip_longest(names, ages, fillvalue="-")
for name, age in combined:
print(name, age)
Výstup:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Závěr
Itertools Pythonu jsou důležitou sadou nástrojů pro vývojáře Pythonu. Itertools Pythonu se široce používají ve funkčním programování, zpracování a transformaci dat, filtrování a výběru dat, seskupování a agregaci, kombinování iterovatelných, kombinatorice a při práci s nekonečnými sekvencemi.
Jako vývojář Pythonu budete mít velký užitek z toho, že se dozvíte o itertools, takže nezapomeňte použít tento článek, abyste se seznámili s Python Itertools.