I følge Pythons dokumentasjon er Itertools en Python-modul som gir et sett med raske og minneeffektive verktøy for å jobbe med Python-iteratorer. Disse verktøyene kan brukes alene eller i kombinasjon, og de gjør det mulig å kortfattet og effektivt lage og arbeide med iteratorer på en rask og minneeffektiv måte.
Itertools-modulen inneholder funksjoner som gjør det lettere å jobbe med iteratorer, spesielt når du håndterer store sett med data. Itertools-funksjoner kan fungere på eksisterende iteratorer for å lage enda mer komplekse Python-iteratorer.
I tillegg kan Itertools hjelpe utviklere med å redusere feil når de jobber med iteratorer og skrive renere, lesbar og vedlikeholdbar kode.
Basert på funksjonaliteten som iteratorene i Itertools-modulen tilbyr, kan de klassifiseres i følgende typer:
Innholdsfortegnelse
#1. Uendelige iteratorer
Dette er iteratorer som lar deg jobbe med uendelige sekvenser og kjøre en sløyfe i det uendelige hvis det ikke er noen betingelse for å bryte ut av sløyfen. Slike iteratorer er nyttige når du simulerer uendelige løkker eller genererer en ubegrenset sekvens. Itertools har tre uendelige iteratorer, som inkluderer count(), cycle() og repeat().
#2. Kombinatoriske iteratorer
Kombinatoriske iteratorer omfatter funksjoner som kan brukes til å arbeide med kartesiske produkter og utføre kombinasjoner og permutasjoner av elementer inneholdt i en iterabel. Dette er de viktigste funksjonene når du prøver å finne alle mulige måter å ordne eller kombinere elementer i en iterabel. Itertools har fire kombinatoriske iteratorer. Disse er produkt(), permutasjoner(), kombinasjoner() og kombinasjoner_med_erstatning().
#3. Iteratorer som avsluttes på den korteste inngangssekvensen
Dette er terminerende iteratorer som brukes på endelige sekvenser og genererer en utgang basert på typen funksjon som brukes. Eksempler på disse avsluttende iteratorene inkluderer: accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), parvis(), starmap(), takewhile (), tee() og zip_longest().
La oss se på hvordan forskjellige Itertools-funksjoner fungerer i henhold til deres type:
Uendelige iteratorer
De tre uendelige iteratorene inkluderer:
#1. telle()
Funksjonen telle(start, trinn) genererer en uendelig rekkefølge av tall som starter fra startverdien. Funksjonen tar to valgfrie argumenter: start og trinn. Argumentet start angir hvor rekkefølgen av tall skal starte. Som standard starter den på 0 hvis en startverdi ikke er oppgitt. trinn angir forskjellen mellom hvert påfølgende tall. Standard trinnverdi 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
Produksjon
4 6 8 10 12
#2. syklus()
cycle(iterable)-funksjonen tar en iterabel som et argument og går deretter gjennom den iterable og gir tilgang til elementer i den iterable i den rekkefølgen de vises.
For eksempel hvis vi går inn [“red”, “green”, “yellow”] into cycle(), i den første syklusen, vil vi ha tilgang til «red»; i den andre syklusen vil vi ha tilgang til «grønn», deretter «gul». I den fjerde syklusen, siden alle elementene er uttømt i den iterable, starter vi på nytt ved «rød» og fortsetter så i det uendelige.
Når du kaller cycle() lagrer du resultatet i en variabel for å lage en iterator som opprettholder tilstanden. Dette sikrer at syklusen ikke starter på nytt hver gang, og gir deg tilgang til kun det første elementet.
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))
Produksjon:
red green yellow red green yellow red
#3. gjenta()
repeat(elem,n) tar to argumenter, et element for å gjenta (elem), og antall ganger du vil gjenta elementet(n). Elementet du vil gjenta kan være en enkelt verdi eller en iterabel. Hvis du ikke passerer inn, n, vil elementet bli gjentatt i det uendelige.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Produksjon:
10 10 10
Kombinatoriske iteratorer
De kombinatoriske iteratorene inkluderer:
#1. produkt()
product() er en funksjon som brukes til å beregne det kartesiske produktet av den iterable som sendes til den. Hvis vi har to iterabler eller sett, for eksempel x = {7,8} og y = {1,2,3}, vil det kartesiske produktet av x og y inneholde alle mulige kombinasjoner av elementer fra x og y, hvor første element er fra x og det andre fra y. Det kartesiske produktet av x og y i dette tilfellet er [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() tar en valgfri parameter kalt repeat som brukes til å beregne det kartesiske produktet av en iterabel med seg selv. repeat angir antall repetisjoner for hvert element fra input iterables ved beregning av det kartesiske produktet.
For eksempel, å kalle product(«ABCD», repeat=2) gir kombinasjoner som («A», «A»), («A», «B»), («A», «C») og så på. Hvis gjentakelse ble satt til 3, ville funksjonen gi kombinasjoner 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])))
Produksjon
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. kombinasjonsmuligheter()
permutasjoner(iterable, group_size) returnerer alle mulige permutasjoner av den iterable som er sendt inn i den. En permutasjon representerer antall måter elementer i et sett kan bestilles på. permutations() tar et valgfritt argument group_size. Hvis group_size ikke er spesifisert, vil de genererte permutasjonene ha samme størrelse som lengden på den iterable som sendes inn i funksjonen
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)
Produksjon
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. kombinasjoner()
kombinasjoner(iterbar, størrelse) returnerer alle mulige kombinasjoner av en iterabel av en gitt lengde fra elementene i den iterable som er sendt inn i funksjonen. Størrelsesargumentet spesifiserer størrelsen på hver kombinasjon.
Resultatene er bestilt. Kombinasjon skiller seg litt fra permutasjoner. Med permutasjon er rekkefølgen viktig, men med kombinasjon spiller rekkefølgen ingen rolle. For eksempel i [A, B, C] det er 6 permutasjoner: AB, AC, BA, BC, CA, CB, men bare 3 kombinasjoner 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)
Produksjon:
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. kombinasjoner_med_erstatning()
kombinasjoner_med_erstatning(iterbar, størrelse) genererer alle mulige kombinasjoner av en iterabel av en gitt lengde fra den iterable som sendes inn i funksjonen og tillater gjentatte elementer i utdatakombinasjonene. Størrelsen bestemmer størrelsen på kombinasjonene som genereres.
Denne funksjonen skiller seg fra kombinasjoner() ved at den gir kombinasjoner der et element kan gjentas mer enn én gang. For eksempel kan du få en kombinasjon som (1,1) som du ikke kan med kombinasjon().
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)
Produksjon
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)]
Avsluttende iteratorer
Dette inkluderer iteratorer som:
#1. akkumulere()
accumulate(iterable, function) tar et iterbart og et andre valgfritt argument som er en funksjon. Den returnerer deretter det akkumulerte resultatet av å bruke funksjonen i hver iterasjon på elementer på den iterable. Hvis ingen funksjon er bestått, legges til og de akkumulerte resultatene 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))
Produksjon:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. kjede()
chain(iterable_1, iterable_2, …) tar flere iterables og lenker dem sammen og produserer en enkelt iterable som inneholder verdier fra de iterablene som er sendt til chain()-funksjonen
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)
Produksjon:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) denne funksjonen ligner på chain(). Imidlertid skiller den seg fra kjeden ved at den bare tar en enkelt iterabel som inneholder sub-iterabler og lenker 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)
Produksjon:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. komprimere()
compress(data, selectors) tar inn to argumenter, data som er en iterabel, og selectors som er en iterabel som inneholder boolske verdier true, og false. 1, 0 kan også brukes som alternativer til de boolske verdiene sant og usant. compress() filtrerer deretter de beståtte dataene ved å bruke de tilsvarende elementene som sendes i velgeren.
Verdier i data som tilsvarer verdien sann eller 1 i velgeren velges, mens resten som tilsvarer usann eller 0 ignoreres. Hvis du sender færre booleaner i velgere enn antall elementer i data, ignoreres alle elementene utover de beståtte booleanerne i velgere
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)
Produksjon:
['A', 'C', 'F', 'G', 'I']
#5. dropwhile()
dropwhile(funksjon, sekvens) tar inn en funksjon med betingelsen som returnerer sant eller usant og en sekvens av verdier. Deretter slipper den alle verdier til betingelsen som ble bestått returnerer False. Når betingelsen returnerer usann, inkluderes resten av elementene i resultatene uavhengig av 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)
Produksjon:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filterfalse()
filterfalse(funksjon, sekvens) tar inn en funksjon, med en betingelse som evalueres til sann eller usann og en sekvens. Den returnerer deretter verdier fra sekvensen som ikke tilfredsstiller betingelsen i funksjonen.
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)
Produksjon:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. gruppe av()
groupby(iterable, key) tar inn en iterabel og en nøkkel, og lager deretter en iterator som returnerer påfølgende nøkler og grupper. For at den skal fungere, må den iterable som sendes til den, sorteres på samme nøkkelfunksjon. Nøkkelfunksjonen datamaskin en nøkkelverdi for hvert element i 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))
Produksjon:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice (iterbar, start, stopp, trinn) lar deg skjære en iterabel ved å bruke start-, stopp- og trinnverdiene som er bestått. Trinn-argumentet er valgfritt. Tellingen starter fra 0 og varen på stoppnummeret er ikke inkludert.
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)
Produksjon:
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 påfølgende overlappende par tatt fra iterablen som er sendt til den i den rekkefølgen de vises i iterablen. Hvis iterablen som sendes til den har mindre enn to verdier, vil resultatet fra parvis() 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)))
Produksjon:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. stjernekart()
starmap(function, iterable) er en funksjon som brukes i stedet for map() når argumentparametere allerede er gruppert i tupler. startmap() bruker en funksjon på elementene i iterablen som er sendt til den. Den iterable skal ha elementer gruppert 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)))
Produksjon:
[13, 5, 9, 16, 11]
#11. ta mens()
takewhile(funksjon, iterable) fungerer på motsatt måte av dropwhile(). takewhile() tar inn en funksjon med en betingelse som skal evalueres og en iterabel. Den inkluderer da alle elementene i iterablen som tilfredsstiller betingelsen i funksjonen til False returneres. Når False er returnert, ignoreres alle følgende elementer i iterablen.
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)
Produksjon:
[1, 2, 3, 4]
#12. tee()
tee(iterbar, n) tar inn en iterabel og returnerer flere uavhengige iteratorer. Antall iteratorer som skal returneres er satt av 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))
Produksjon:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#1. 3. zip_longest()
zip_longest(iterables, fillvalue) tar inn flere iteratorer og en fillvalue. Den returnerer deretter en iterator som samler elementer fra hver av iteratorene som sendes til den. Hvis iteratorene ikke er av samme lengde, erstattes de manglende verdiene med fyllverdien som sendes til funksjonen til den lengste iterable er oppbrukt.
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)
Produksjon:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Konklusjon
Python itertools er et viktig verktøysett for en Python-utvikler. Python itertools brukes mye i funksjonell programmering, databehandling og transformasjon, datafiltrering og -seleksjon, gruppering og aggregering, kombinere iterables, kombinatorikk, og når du arbeider med uendelige sekvenser.
Som Python-utvikler vil du ha stor nytte av å lære om itertools, så sørg for å bruke denne artikkelen for å gjøre deg kjent med Python Itertools.