Wat zijn Python Itertools-functies?

Volgens de documentatie van Python is Itertools een Python-module die een set snelle en geheugenefficiënte hulpmiddelen biedt voor het werken met Python iteratoren. Deze tools kunnen afzonderlijk of in combinatie worden gebruikt en ze maken het mogelijk om op een beknopte en efficiënte manier iteratoren te maken en ermee te werken op een snelle en geheugenefficiënte manier.

De module Itertools bevat functies die het gemakkelijker maken om met iteratoren te werken, vooral bij het verwerken van grote gegevenssets. Itertools-functies kunnen op bestaande iteratoren werken om nog complexere Python iteratoren te maken.

Daarnaast kan Itertools ontwikkelaars helpen fouten te verminderen bij het werken met iteratoren en schonere, leesbare en onderhoudbare code te schrijven.

Soorten iteratoren in Python Itertools

Gebaseerd op de functionaliteit die de iteratoren in de Itertools module bieden, kunnen ze worden geclassificeerd in de volgende types:

#1. Eenindige Iteratoren

Dit zijn iteratoren die je toelaten om met oneindige reeksen te werken en een lus oneindig te laten lopen als er geen voorwaarde is om de lus te verbreken. Zulke iteratoren zijn handig bij het simuleren van oneindige lussen of het genereren van een onbegrensde reeks. Itertools heeft drie oneindige iteratoren, waaronder tellen(), cyclus() en herhalen().

#2. Combinatorische iteratoren

Combinatorische iteratoren bestaan uit functies die kunnen worden gebruikt om te werken met cartesische producten en om combinaties en permutaties uit te voeren van elementen in een iterabele. Dit zijn de functies die je moet gebruiken om alle mogelijke manieren te vinden om elementen in een iterabel te rangschikken of te combineren. Itertools heeft vier combinatorische iteratoren. Dit zijn product(), permutaties(), combinaties() en combinaties_met_vervanging().

#3. Iteratoren die eindigen op de kortste invoerreeks

Dit zijn terminerende iteratoren die gebruikt worden op eindige reeksen en een uitvoer genereren gebaseerd op het type van de gebruikte functie. Voorbeelden van deze terminerende iteratoren zijn: accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile(), tee() en zip_langste().

Laten we eens kijken hoe verschillende Itertools functies werken volgens hun type:

Eenindige iteratoren

De drie eenindige iteratoren zijn:

#1. tellen()

De functie count(start, step) genereert een oneindige reeks getallen beginnend bij de startwaarde. De functie neemt twee optionele argumenten: start en niet. Het argument start stelt in waar de getallenreeks moet beginnen. Het begint standaard bij 0 als er geen startwaarde is opgegeven. niet stelt het verschil in tussen elk opeenvolgend getal. De standaard stapwaarde is 1.

import itertools
# tel vanaf 4, en maak stappen van 2 
voor i in itertools.count(4, 2):
   # voorwaarde om de lus te beëindigen om oneindige lussen te voorkomen
 als i == 14:
 break
 else:
 print(i) # uitvoer - 4, 6, 8, 10, 12

Uitvoer

4
6
8
10
12

#2. cyclus()

cycle(iterable) functie neemt een iterable als argument en cycles dan door de iterable waardoor toegang tot items in de iterable in de volgorde waarin ze verschijnen.

Als we bijvoorbeeld ["rood", "groen", "geel"] in cyclus() invoeren, hebben we in de eerste cyclus toegang tot "red"; in de tweede cyclus hebben we toegang tot "green", dan tot "yellow". In de vierde cyclus, omdat alle elementen in de iterable zijn uitgeput, zullen we opnieuw beginnen bij "rood" en dan oneindig doorgaan.

Wanneer je cycle() aanroept, sla je het resultaat op in een variabele om een iterator te maken die zijn status behoudt. Dit zorgt ervoor dat de cyclus niet elke keer opnieuw begint, waardoor je alleen toegang hebt tot het eerste element.

import itertools

colors = ["red", "green", "yellow"]
# geef kleuren door in cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)

# range gebruikt om de oneindige lus te stoppen zodra we 7 keer hebben afgedrukt
# next() gebruikt om het volgende element van de iterator terug te geven
for i in range(7):
 print(next(color_cycle))

Uitvoeren:

rood
groen
geel
rood
groen
geel
rood

#3. herhaal()

repeat(elem,n) heeft twee argumenten, een element om te herhalen(elem) en het aantal keren dat je het element wilt herhalen(n). Het element dat je wilt herhalen kan een enkele waarde of een iterable zijn. Als je geen n opgeeft, wordt het element oneindig herhaald.

import itertools
   
voor i in itertools.repeat(10, 3):
 print(i)

Uitvoeren:

10 
10
10

Combinatorische iteratoren

De combinatorische iteratoren omvatten:

#1. product()

product() is een functie die wordt gebruikt om het cartesisch product te berekenen van de iterabele die eraan wordt doorgegeven. Als we twee iterabelen of verzamelingen hebben, bijvoorbeeld x = {7,8} en y = {1,2,3}, zal het cartesisch product van x en y alle mogelijke combinaties van elementen uit x en y bevatten, waarbij het eerste element uit x komt en het tweede uit y. Het cartesisch product van x en y in dit geval is [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].

product() neemt een optionele parameter genaamd herhaal die wordt gebruikt om het cartesisch product van een iterable met zichzelf te berekenen. herhaal specificeert het aantal herhalingen voor elk element uit de invoer iterables bij het berekenen van het cartesisch product.

Bijvoorbeeld, het aanroepen van product('ABCD', repeat=2) levert combinaties op zoals ('A', 'A'), ('A', 'B'), ('A', 'C'), enzovoort. Als repeat is ingesteld op 3, zou de functie combinaties opleveren zoals ('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A', 'C'), ('A', 'A', 'D'), enzovoort.

from itertools import product
# product() met het optionele herhalingsargument
print("product() met het optionele herhalingsargument ")
print(list(product('ABC', repeat = 2))

# product zonder herhalingsargument
print("product() ZONDER een optioneel herhalingsargument")
print(list(product([7,8], [1,2,3]))

Uitvoer

product() met het optionele herhalingsargument 
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() ZONDER een optioneel herhalingsargument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]

#2. permutaties()

permutaties(iterable, groep_grootte) geeft alle mogelijke permutaties van de iterable die erin wordt doorgegeven. Een permutatie vertegenwoordigt het aantal manieren waarop elementen in een verzameling geordend kunnen worden. permutaties() neemt een optioneel argument groep_grootte. Als groep_grootte niet is opgegeven, zullen de gegenereerde permutaties zelfs groot zijn als de lengte van de iterabele die aan de functie is doorgegeven

import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))

print("Permutaties met een grootte van 2")
print(sized_permutations)
print("Permutaties zonder argument grootte")
print(unsized_permuatations)

Uitvoer

Permutaties met een groepsgrootte van 2
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
Permutaties met GEEN GROOTTE-argument
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

#3. combinaties()

combinations(iterable, grootte) retourneert alle mogelijke combinaties van een iterable van een gegeven lengte uit de elementen in de iterable die in de functie zijn doorgegeven. Het argument grootte specificeert de grootte van elke combinatie.

De resultaten worden geordend. Combinatie verschilt enigszins van permutaties. Bij permutatie doet de volgorde ertoe, maar bij combinatie doet de volgorde er niet toe. Bijvoorbeeld, in [A, B, C] zijn er 6 permutaties: AB, AC, BA, BC, CA, CB maar slechts 3 combinaties 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("Combinaties met een grootte van 2")
print(size2_combination)
print("Combinaties met een grootte van 3")
print(size3_combination)

Uitvoeren:

Combinaties met een grootte van 2
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
Combinaties met een grootte van 3
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]

#4. combinaties_met_vervanging()

combinations_with_replacement(iterable, grootte) genereert alle mogelijke combinaties van een iterable van een gegeven lengte uit de iterable die in de functie wordt doorgegeven en staat herhaalde elementen toe in de uitvoercombinaties. De grootte bepaalt de grootte van de gegenereerde combinaties.

Deze functie verschilt van combinaties() in die zin dat het combinaties geeft waarbij een element meer dan eens herhaald kan worden. Je kunt bijvoorbeeld een combinatie als (1,1) krijgen die je niet kunt krijgen met combinatie().

import itertools
numbers = [1, 2, 3,4]

size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinaties_met_vervanging => grootte 2")
print(size2_combination)

Uitvoer

Combinaties_met_vervanging => grootte 2
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]

Beëindigende iteratoren

Dit omvat iteratoren zoals:

#1. accumuleren()

accumulate(iterable, functie) neemt een iterable en een tweede optioneel argument dat een functie is. Het geeft dan het geaccumuleerde resultaat terug van het toepassen van de functie in elke iteratie op elementen in de iterable. Als er geen functie wordt doorgegeven, wordt er opgeteld en worden de geaccumuleerde resultaten geretourneerd.

import itertools
import operator
numbers = [1, 2, 3, 4, 5]

# Accumuleer de som van getallen
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumuleer zonder functie")
print(list(accumulated_val))
print("Accumuleer met vermenigvuldiging")
print(list(accumulated_mul))

Uitvoeren:

Accumuleren zonder functie
[1, 3, 6, 10, 15]
Accumuleren met vermenigvuldiging
[1, 2, 6, 24, 120]

#2. ketting()

chain(iterable_1, iterable_2, ...) neemt meerdere iterabelen en ketent ze aan elkaar en produceert een enkele iterabel die waarden bevat van de iterabelen die zijn doorgegeven aan de chain() functie

import itertools

letters = ['A', 'B', 'C', 'D']
getallen = [1, 2, 3]
kleuren = ['rood', 'groen', 'geel']

# ketens letters en getallen aan elkaar
chained_iterable = list(itertools.chain(letters, getallen, kleuren))
print(chained_iterable)

Uitvoeren:

['A', 'B', 'C', 'D', 1, 2, 3, 'rood', 'groen', 'geel']

#3. keten.van_herhaalbare()

chain.from_iterable(iterable) deze functie is vergelijkbaar met chain(). Het verschilt echter van chain in het feit dat het slechts een enkele iterable neemt die subiterables bevat en deze aan elkaar ketent.

import itertools

letters = ['A', 'B', 'C', 'D']
getallen = [1, 2, 3]
kleuren = ['rood', 'groen', 'geel']

iterable = ['hallo',kleuren, letters, getallen]
chain = list(itertools.chain.from_iterable(iterable))
print(chain)

Uitvoeren:

['h', 'e', 'l', 'o', 'rood', 'groen', 'geel', 'A', 'B', 'C', 'D', 1, 2, 3]

#4. comprimeer()

compress(data, selectors) heeft twee argumenten, gegevens is een iterable en selecteurs is een iterable die de booleans true en false bevat. 1, 0 kunnen ook worden gebruikt als alternatieven voor de booleaanse waarden true en false. compress() filtert vervolgens de doorgegeven gegevens met behulp van de overeenkomstige elementen die zijn doorgegeven in de selecteur.

Waarden in gegevens die overeenkomen met de waarde Echt van 1 in de selector worden geselecteerd, terwijl de rest die overeenkomt met vals van 0 wordt genegeerd. Als je minder booleans in selecteurs doorgeeft dan het aantal items in gegevens worden alle elementen voorbij de doorgegeven booleans in selecteurs genegeerd

import itertools

# data heeft 10 items
data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
# 9 selector-items doorgeven
selectors = [True, False, 1, False, 0, 1, True, False, 1]

# Selecteer elementen uit data op basis van selectors
filtered_data = list(itertools.compress(data, selectors))
print(filtered_data)

Uitvoeren:

['A', 'C', 'F', 'G', 'I']

#5. dropwhile()

dropwhile(functie, reeks) neemt een functie met de voorwaarde die waar of onwaar retourneert en een reeks waarden. Het laat dan alle waarden vallen totdat de doorgegeven voorwaarde Onwaar retourneert. Zodra de voorwaarde onwaar retourneert, worden de rest van de elementen opgenomen in de resultaten, ongeacht of ze Waar of Onwaar retourneert.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Laat elementen vallen totdat de doorgegeven voorwaarde False is
filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Uitvoeren:

[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

#6. filterfalse()

filterfalse(functie, reeks) neemt een functie, met een voorwaarde die evalueert naar waar of onwaar en een reeks. Het retourneert dan waarden uit de reeks die niet voldoen aan de voorwaarde in de functie.

import itertools

numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3]

# Filter elementen waarvoor de voorwaarde False is
filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers))
print(filtered_numbers)

Uitvoeren:

[4, 5, 6, 5, 8, 6, 7, 4]

#7. groep()

groupby(iterable, key) neemt een iterable en een sleutel op en maakt dan een iterator die opeenvolgende sleutels en groepen teruggeeft. Om het te laten werken, moet de iterable die eraan wordt doorgegeven gesorteerd zijn op dezelfde sleutelfunctie. De sleutelfunctie berekent een sleutelwaarde voor elk element in de iterable.

import itertools

input_list = [("Binnenlands", "Koe"), ("Binnenlands", "Hond"), ("Binnenlands", "Kat"),("Wild", "Leeuw"), ("Wild", "Zebra"), ("Wild", "Olifant")]
classificatie = itertools.groupby(input_list,lambda x: x[0])
voor sleutel,waarde in classificatie:
 print(sleutel,":",lijst(waarde))

Uitgang:

Binnenlands : [('Binnenlands', 'Koe'), ('Binnenlands', 'Hond'), ('Binnenlands', 'Kat')]
Wild : [('Wild', 'Leeuw'), ('Wild', 'Zebra'), ('Wild', 'Olifant')]

#8. islice()

islice(iterable, start, stop, step) staat je toe om een iterable te slicen door de starten, stoppen en stap waarden. Het argument stap is optioneel. Tellen begint vanaf 0 en het item op het stop-argument wordt niet meegenomen.

import itertools

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

# Selecteer elementen binnen een bereik
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice zonder een stapwaarde in te stellen")
print(selected_numbers)
print("islice met een stapwaarde van 2")
print(selected_numbers_step)

Uitvoeren:

islice zonder een stapwaarde in te stellen
[3, 4, 5, 6, 7, 8, 9, 10]
islice met een stapwaarde van 2
[3, 5, 7, 9]

#9. paarsgewijs()

pairwise(iterable) retourneert opeenvolgende overlappende paren uit de iterable die wordt doorgegeven in de volgorde waarin ze in de iterable voorkomen. Als de iterable die wordt doorgegeven minder dan twee waarden heeft, zal het resultaat van pairwise() leeg zijn.

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

Uitvoeren:

[(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(functie, iterable) is een functie die wordt gebruikt in plaats van map() als de argumentparameters al zijn gegroepeerd in tuples. startmap() past een functie toe op de elementen van de iterable die eraan wordt doorgegeven. De iterable moet elementen hebben die zijn gegroepeerd in tuples.

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

Uitvoeren:

[13, 5, 9, 16, 11]

#11. takewhile()

takewhile(functie, iterable) werkt op de tegenovergestelde manier als dropwhile(). takewhile() neemt een functie met een voorwaarde die geëvalueerd moet worden en een iterable. Het bevat dan alle elementen in de iterable die voldoen aan de voorwaarde in de functie totdat False wordt geretourneerd. Zodra False wordt geretourneerd, worden alle volgende elementen in de iterable genegeerd.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Laat elementen vallen totdat de doorgegeven voorwaarde False is
filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Uitvoeren:

[1, 2, 3, 4]

#12. tee()

tee(iterable, n) neemt een iterable op en geeft meerdere onafhankelijke iterators terug. Het aantal iteratoren dat wordt teruggegeven, wordt ingesteld door nwat standaard 2 is.

import itertools

numbers = [1, 2, 3, 4, 5]

# Maak twee onafhankelijke iteratoren van getallen
iter1, iter2 = itertools.tee(numbers, 2)
print(list(iter1))
print(list(iter2))

Uitvoeren:

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

#13. zip_langste()

zip_longest(iterables, fillvalue) neemt meerdere iterators en een fillvalue. Het geeft dan een iterator terug die elementen van elk van de doorgegeven iterators samenvoegt. Als de iteratoren niet even lang zijn, worden de ontbrekende waarden vervangen door de filwaarde die aan de functie is doorgegeven, totdat de langste iterabel is uitgeput.

import itertools

namen = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
leeftijden = [25, 30, 12, 13, 42]

# Combineer naam en leeftijden en vul ontbrekende leeftijden aan met een streepje
combined = itertools.zip_longest(names, ages, fillvalue="-")

for name, age in combined:
 print(name, age)

Uitvoeren:

John 25
mathew 30
mary 12
Alice 13
Bob 42
Charlie -
Fury -

Conclusie

Python itertools zijn een belangrijke toolset voor een Python-ontwikkelaar. Python itertools worden veel gebruikt bij functioneel programmerengegevensverwerking en -transformatie, filteren en selecteren van gegevens, groeperen en aggregeren, combineren van iterabelen, combinatoriek en bij het werken met oneindige reeksen.

Als Python-ontwikkelaar zul je veel baat hebben bij het leren kennen van itertools, dus zorg ervoor dat je dit artikel gebruikt om vertrouwd te raken met Python Itertools.