Ifølge Pythons dokumentation er Itertools et Python-modul, der giver et sæt hurtige og hukommelseseffektive værktøjer til at arbejde med Python-iteratorer. Disse værktøjer kan bruges alene eller i kombination, og de gør det muligt kortfattet og effektivt at skabe og arbejde med iteratorer på en hurtig og hukommelseseffektiv måde.
Itertools-modulet indeholder funktioner, der gør det nemmere at arbejde med iteratorer, især ved håndtering af store datasæt. Itertools-funktioner kan arbejde på eksisterende iteratorer for at skabe endnu mere komplekse Python-iteratorer.
Derudover kan Itertools hjælpe udviklere med at reducere fejl, når de arbejder med iteratorer og skrive renere, læsbar og vedligeholdelig kode.
Baseret på den funktionalitet, som iteratorerne i Itertools-modulet tilbyder, kan de klassificeres i følgende typer:
Indholdsfortegnelse
#1. Uendelige iteratorer
Disse er iteratorer, der giver dig mulighed for at arbejde med uendelige sekvenser og køre en løkke uendeligt, hvis der ikke er nogen betingelse for at bryde ud af løkken. Sådanne iteratorer er nyttige, når du simulerer uendelige sløjfer eller genererer en ubegrænset sekvens. Itertools har tre uendelige iteratorer, som inkluderer count(), cycle() og repeat().
#2. Kombinatoriske iteratorer
Kombinatoriske iteratorer omfatter funktioner, der kan bruges til at arbejde på kartesiske produkter og udføre kombinationer og permutationer af elementer indeholdt i en iterabel. Disse er de vigtigste funktioner, når man forsøger at finde alle mulige måder at arrangere eller kombinere elementer i en iterabel. Itertools har fire kombinatoriske iteratorer. Disse er produkt(), permutationer(), kombinationer() og kombinationer_med_erstatning().
#3. Iteratorer afsluttes på den korteste inputsekvens
Disse er afsluttende iteratorer, der bruges på endelige sekvenser og genererer et output baseret på den anvendte funktionstype. Eksempler på disse afsluttende iteratorer inkluderer: accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), parvis(), starmap(), takewhile (), tee() og zip_longest().
Lad os se på, hvordan forskellige Itertools-funktioner fungerer efter deres type:
Uendelige iteratorer
De tre uendelige iteratorer inkluderer:
#1. tælle()
Funktionen tælle(start, trin) genererer en uendelig talrække fra startværdien. Funktionen tager to valgfrie argumenter: start og trin. Argumentet start angiver, hvor rækkefølgen af tal skal starte. Som standard starter den ved 0, hvis der ikke er angivet en startværdi. trin indstiller forskellen mellem hvert fortløbende tal. Standardtrinværdien er 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
Produktion
4 6 8 10 12
#2. cyklus()
cyklus(iterable)-funktionen tager en iterabel som et argument og går derefter gennem den iterable og giver adgang til elementer i den iterable i den rækkefølge, de vises.
For eksempel, hvis vi går ind [“red”, “green”, “yellow”] into cycle(), i den første cyklus har vi adgang til “red”; i anden cyklus har vi adgang til “grøn”, derefter “gul”. I den fjerde cyklus, da alle elementer er udtømt i den iterable, starter vi forfra ved “rød” og fortsætter derefter i det uendelige.
Når du kalder cycle(), gemmer du dets resultat i en variabel for at skabe en iterator, der bevarer sin tilstand. Dette sikrer, at cyklussen ikke starter forfra hver gang, hvilket giver dig adgang til kun det første element.
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))
Produktion:
red green yellow red green yellow red
#3. gentage()
repeat(elem,n) tager to argumenter, et element for at gentage (elem), og det antal gange, du vil gentage elementet(n). Det element, du vil gentage, kan være en enkelt værdi eller en iterabel. Hvis du ikke går ind, n, vil elementet blive gentaget uendeligt.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Produktion:
10 10 10
Kombinatoriske iteratorer
De kombinatoriske iteratorer inkluderer:
#1. produkt()
product() er en funktion, der bruges til at beregne det kartesiske produkt af den iterable, der sendes til den. Hvis vi har to iterabler eller mængder, for eksempel x = {7,8} og y = {1,2,3}, vil det kartesiske produkt af x og y indeholde alle mulige kombinationer af elementer fra x og y, hvor første element er fra x og det andet fra y. Det kartesiske produkt af x og y er i dette tilfælde [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() tager en valgfri parameter kaldet repeat, som bruges til at beregne det kartesiske produkt af en iterabel med sig selv. repeat angiver antallet af gentagelser for hvert element fra input iterables ved beregning af det kartesiske produkt.
For eksempel giver kald af product(‘ABCD’, repeat=2) kombinationer som (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’) og så på. Hvis gentagelse blev sat til 3, ville funktionen give kombinationer såsom (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’ , ‘C’), (‘A’, ‘A’, ‘D’) og så videre.
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])))
Produktion
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. permutationer()
permutations(iterable, group_size) returnerer alle mulige permutationer af den iterable, der er sendt ind i den. En permutation repræsenterer antallet af måder, elementer i et sæt kan bestilles på. permutations() tager et valgfrit argument group_size. Hvis group_size ikke er angivet, vil de genererede permutationer have samme størrelse som længden af den iterable, der sendes til funktionen
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)
Produktion
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. kombinationer()
kombinationer(iterbar, størrelse) returnerer alle mulige kombinationer af en iterabel af en given længde fra elementerne i den iterable, der er overført til funktionen. Størrelsesargumentet angiver størrelsen af hver kombination.
Resultaterne er bestilt. Kombination adskiller sig lidt fra permutationer. Med permutation betyder rækkefølgen noget, men med kombination er rækkefølgen ligegyldig. For eksempel i [A, B, C] der er 6 permutationer: AB, AC, BA, BC, CA, CB men kun 3 kombinationer 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)
Produktion:
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. kombinationer_med_erstatning()
kombinationer_med_erstatning(iterbar, størrelse) genererer alle mulige kombinationer af en iterabel af en given længde fra den iterable, der er overført til funktionen og giver mulighed for gentagne elementer i outputkombinationerne. Størrelsen bestemmer størrelsen af de genererede kombinationer.
Denne funktion adskiller sig fra kombinationer() ved, at den giver kombinationer, hvor et element kan gentages mere end én gang. For eksempel kan du få en kombination som (1,1), hvilket du ikke kan med kombination().
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)
Produktion
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)]
Afsluttende iteratorer
Dette inkluderer iteratorer som:
#1. ophobe()
accumulate(iterable, function) tager et iterbart og et andet valgfrit argument, som er en funktion. Det returnerer derefter det akkumulerede resultat af at anvende funktionen i hver iteration på elementer på den iterable. Hvis ingen funktion er bestået, tilføjes, og de akkumulerede resultater returneres.
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))
Produktion:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. kæde()
chain(iterable_1, iterable_2, …) tager flere iterables og kæder dem sammen og producerer en enkelt iterable indeholdende værdier fra de iterables, der er sendt til chain()-funktionen
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)
Produktion:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) denne funktion ligner chain(). Den adskiller sig dog fra kæden ved, at den kun tager en enkelt iterabel indeholdende sub-iterables og kæder dem sammen.
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)
Produktion:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. komprimere()
compress(data, selectors) tager to argumenter ind, data, som er en iterabel, og selectors, som er en iterabel, der indeholder booleanske værdier sand og false. 1, 0 kan også bruges som alternativer til de boolske værdier sand og falsk. compress() filtrerer derefter de overførte data ved hjælp af de tilsvarende elementer, der sendes i vælgeren.
Værdier i data, der svarer til værdien sand eller 1 i vælgeren, vælges, mens resten, der svarer til falsk eller 0, ignoreres. Hvis du sender færre booleaner i vælgere end antallet af elementer i data, ignoreres alle elementer ud over de beståede booleaner i vælgere
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)
Produktion:
['A', 'C', 'F', 'G', 'I']
#5. dropwhile()
dropwhile(funktion, sekvens) tager en funktion ind med betingelsen, der returnerer sand eller falsk og en sekvens af værdier. Derefter taber den alle værdier, indtil den beståede betingelse returnerer False. Når betingelsen returnerer falsk, inkluderes resten af elementerne i dens resultater, uanset om de returnerer True eller 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)
Produktion:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filterfalse()
filterfalse(funktion, sekvens) tager en funktion ind med en betingelse, der evalueres til sand eller falsk og en sekvens. Den returnerer derefter værdier fra sekvensen, som ikke opfylder betingelsen i funktionen.
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)
Produktion:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. groupby()
groupby(iterable, key) tager en iterabel og en nøgle ind, og laver derefter en iterator, der returnerer på hinanden følgende nøgler og grupper. For at det kan fungere, skal den iterable, der sendes til den, sorteres på den samme nøglefunktion. Nøglefunktionscomputeren en nøgleværdi for hvert element i den iterable.
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))
Produktion:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice(iterbar, start, stop, trin) giver dig mulighed for at opdele en iterabel ved at bruge de beståede start-, stop- og trinværdier. Trin-argumentet er valgfrit. Optællingen starter fra 0 og punktet på stopnummeret er ikke inkluderet.
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)
Produktion:
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. parvis()
pairwise(iterable) returnerer successive overlappende par taget fra den iterable, der er overført til den i den rækkefølge, de vises i den iterable. Hvis den iterable, der sendes til den, har mindre end to værdier, vil resultatet fra pairwise() være tomt.
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)))
Produktion:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. starmap()
starmap(funktion, iterable) er en funktion, der bruges i stedet for map(), når argumentparametre allerede er grupperet i tupler. startmap() anvender en funktion på elementerne i den iterable, der er sendt til den. Den iterable skal have elementer grupperet i tupler.
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)))
Produktion:
[13, 5, 9, 16, 11]
#11. tage mens ()
takewhile(funktion, iterable) virker på den modsatte måde af dropwhile(). takewhile() tager en funktion med en betingelse, der skal evalueres, og en iterabel. Det inkluderer derefter alle elementer i iterablen, som opfylder betingelsen i funktionen, indtil False returneres. Når False er returneret, ignoreres alle følgende elementer i den iterable.
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)
Produktion:
[1, 2, 3, 4]
#12. tee()
tee(iterbar, n) tager en iterabel ind og returnerer flere uafhængige iteratorer. Antallet af iteratorer, der skal returneres, er angivet med n, som som standard er 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))
Produktion:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) tager flere iteratorer og en fillvalue. Det returnerer derefter en iterator, der samler elementer fra hver af de iteratorer, der sendes til den. Hvis iteratorerne ikke er af samme længde, erstattes de manglende værdier med fyldværdien, der sendes til funktionen, indtil den længste iterable er opbrugt.
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)
Produktion:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Konklusion
Python itertools er et vigtigt værktøjssæt for en Python-udvikler. Python itertools bruges i vid udstrækning i funktionel programmering, databehandling og transformation, datafiltrering og udvælgelse, gruppering og aggregering, kombination af iterables, kombinatorik og når der arbejdes med uendelige sekvenser.
Som Python-udvikler vil du få stor gavn af at lære om itertools, så sørg for at bruge denne artikel til at blive fortrolig med Python Itertools.