Iterators in Python

Een iterator is een waardevol hulpmiddel voor Python. Het is een object dat wordt gebruikt om alle elementen van een verzameling te herhalen. Iterator geeft toegang tot de elementen van een container, maar doet de iteratie niet alleen. Het werkt als een databasecursor en wordt gebruikt om de recordlijst één voor één te lezen. Bijvoorbeeld een 'voor' lus die de waarden van een container herhaalt, werkt als een iterator. Python heeft veel ingebouwde iterators voor itereerbare objecten, zoals lijsten, tupels, woordenboeken, enz. Zonder deze iterators, 'itertools' functies kunnen worden gebruikt om andere iterators in Python te retourneren. Dit artikel laat zien hoe je de lus kunt gebruiken als een iterator, aangepaste iterator, oneindige iterator en controle oneindige iterator in Python 3. Sommige toepassingen van de 'itertools' functies worden ook uitgelegd in het laatste deel van deze tutorial.

Iterator-methoden

Elk iteratorobject bevat de volgende twee methoden:.

• _ _iter_ _()

Deze methode wordt gebruikt om het itereerbare object te initialiseren. Het geretourneerde object heeft de methode '_ _De volgende_ _()' in Python 3.

• _ _De volgende_ _()

Deze methode retourneert de volgende waarde van het itereerbare object. De relatie tussen de iterator en het itereerbare object wordt weergegeven in het volgende diagram:.

Itereren met lussen

Eerder werd vermeld dat de 'voor' lus roept de 'De volgende()' methode impliciet bij het herhalen van een willekeurig object. Wanneer een lus wordt gebruikt voor het herhalen van een itereerbaar object, wordt de 'voor' lus roept de 'De volgende()' methode impliciet en de 'terwijl' lus roept de 'De volgende()' of '__De volgende__()' methode expliciet om de volgende waarde van het itereerbare object te lezen. Beide typen lussen blijven deze methode aanroepen totdat de 'StopIteratie' signaal wordt gegenereerd.

Voorbeeld 1: Itereerbare objecten herhalen met een 'for'-lus

Het volgende script toont het gebruik van 'voor' loops voor het herhalen van vijf verschillende itereerbare objecten. De eerste 'voor' loop wordt gebruikt om de tekenreekswaarde te herhalen en elk teken van de tekenreeks in elke iteratie af te drukken. De seconde 'voor' loop wordt gebruikt om de inhoud van een bestaand tekstbestand te herhalen en elke regel van het bestand in elke iteratie af te drukken. De derde 'voor' loop wordt gebruikt om de waarden van een tuple te herhalen it. De vierde 'voor' loop wordt gebruikt om de waarden in een lijst te herhalen it. De vijfde 'voor' loop wordt gebruikt om de waarden in een woordenboek te herhalen.

# Een string herhalen met de for-lus
print ("String Iteratie met for-lus")
str = "Python"
voor val in str:
print(val)
# Een bestaand bestand herhalen met for loop
print("\n\nEen bestand regel voor regel lezen met for loop")
for line in open("test.tekst"):
print(line, end="")
# # Een tuple herhalen met de for-lus
print("\n\nTuple Iteratie met for loop")
tup = ("Boek", "Papier", "Potlood", "Pen")
voor val in tup:
print(val)
# Een lijst herhalen met de for-lus
print("\n\nLijst iteratie met for-lus")
listdata = ["Ontwerper", "Analyst", "Programmeur", "Beheerder"]
voor val in lijstgegevens:
print(val)
# Een woordenboek herhalen met de for-lus
print("\n\nWoordenboek Iteratie met for-lus")
dictval = 'Meher': 95, 'Sakib': 97, 'Akhi': 70, 'Fiaz': 78
voor index in dictval :
print("%s behaalde %d punten" %(index, dictval[index]))

Uitgang:

De volgende uitvoer laat zien dat de tekens van de tekenreekswaarde; de lijnen van de test.tekst het dossier; en de items van de tuples, de lijst en het woordenboek worden afgedrukt nadat het script is uitgevoerd.

Voorbeeld 2: lijsten herhalen met een 'terwijl'-lus

Het volgende script toont het gebruik van een 'terwijl' loop voor het herhalen van een lijst met gegevens. Hier de 'iter()' methode wordt gebruikt om het itereerbare object te initialiseren, en de 'De volgende()' methode wordt gebruikt om de volgende waarde van het itereerbare object te lezen. StopIteratie signaal wordt gebruikt om te eindigen van de oneindige 'terwijl' loop wanneer er geen item van de lijst meer is om te lezen.

# Definieer een lijst
listdata = ['google'.com', 'bing.com','yahoo.com', 'baidu.com', 'duckduckgo'.com']
# Initialiseer het itereerbare object
init_iter_object = iter(lijstgegevens)
print("Iterating List-gegevens met while-lus:\n")
# Declareren en oneindige while-lus
terwijl waar:
proberen:
# next() methode wordt gebruikt om de volgende waarde te herhalen
waarde = volgende(init_iter_object)
print(waarde)
behalve StopIteratie:
# Beëindig de lus na het herhalen van alle waarden
breken

Uitgang:

De volgende uitvoer laat zien dat elke waarde van de lijst in elke regel is afgedrukt met behulp van de 'De volgende()' methode na het uitvoeren van het script.

Voorbeeld 3: Een tuple herhalen met de '__next__()'-methode en de 'while'-lus

In het volgende script worden beide 'De volgende()' en '__De volgende__()' methoden worden gebruikt voor het herhalen van de waarden van een tupletu. De 'iter()' methode wordt gebruikt om het itereerbare object te maken, genaamd 'init_iter.' Hier de 'De volgende()' methode wordt twee keer aangeroepen om de eerste twee waarden van de tuple af te drukken. Vervolgens een oneindige 'terwijl' loop wordt gebruikt om de resterende waarden van de tuple te herhalen en de 'StopIteratie' signaal wordt gebruikt om de lus te beëindigen, zoals in het vorige voorbeeld.

# definieer een tupel
animal_tuple =('Vogel','Leeuw', 'Aap', 'Slang', 'Olifant')
print("De waarden van de tuple zijn:\n")
# Initialiseer een iterator-object met iter()
init_iter = iter(dier_tuple)
# herhaal en print waarde met de methode next()
print(volgende(init_iter))
print(volgende(init_iter))
# Definieer een oneindige while-lus
terwijl waar:
proberen:
# herhaal en print waarde met behulp van __next__() methode)
print(init_iter).__De volgende__())
behalve StopIteratie:
# Beëindig de lus na het herhalen van alle waarden
breken

Uitgang:

De volgende uitvoer laat zien dat na het uitvoeren van het script de eerste twee waarden, 'Vogel' en 'Leeuw,' zijn bedrukt met de 'De volgende()' methode, terwijl de andere drie waarden, 'Aap,"Slang,' en 'Olifant,' zijn bedrukt met de '__De volgende__()' methode'.

Itereren met een aangepaste iterator

Deze sectie laat zien hoe verschillende typen aangepaste iterators kunnen worden geïmplementeerd door klassen te maken. Beide '__iter__()' en de '__De volgende__()' methoden worden geïmplementeerd in een klasse, en de 'terwijl' loop zal worden gebruikt om de waarden van het itereerbare object te herhalen.  Het volgende deel van dit artikel laat ook zien hoe u een oneindige aangepaste iterator kunt maken en de iteratie kunt regelen.

Voorbeeld 4: Gebruik van een eenvoudige aangepaste iterator

Met het volgende script kunt u de waarde van . berekenen X^nee door een aangepaste iterator te gebruiken zonder een ingebouwde functie van Python te gebruiken. De klas genaamd 'x_to_the_power_n' staat in het script. De '__in het__()' methode van de klasse initialiseert de waarden van X en nee die zal worden gebruikt op het moment van het maken van objecten. De '__iter__()' methode initialiseert de klassevariabele, die de 'resultaat' variabele van de berekening in elke iteratie. de waarden van X en nee zal worden genomen als invoer van de gebruiker. Een object van de klasse 'nummers' is gemaakt met X en nee. Vervolgens een itereerbaar object met de naam 'iter_obj' is gemaakt om de '__De volgende__()'methode voor' n-1 keer met behulp van de 'terwijl' lus om de waarde van te berekenen X^nee. In elke iteratie, de waarde van X wordt vermenigvuldigd met de vorige waarde van de 'resultaat'variabele'. Na het beëindigen van de 'terwijl'lus, de'__De volgende__()' wordt opnieuw aangeroepen om de waarde van . af te drukken X^nee.

"Maak een klas om de . te berekenen
x tot de macht n met iterator
"
klasse x_to_the_power_n:
# Initialiseer de waarde van x en n
def __init__(zelf, x=0, n=0):
zelf.x = x
zelf.n = n
# Initialiseer de iterabele
def __iter__(zelf):
zelf.resultaat = 1
zelf terugkeren
# Bereken de waarde in elke iteratie
def __volgende__(zelf):
als zelf.n >= 0:
zelf.resultaat *= zelf.X
zelf.n -= 1
zelf terugkeren.resultaat
# Neem de waarden van x en n
x = int(input("Vul de waarde van x in: "))
n = int(input("Vul de waarde van n in: "))
# Maak een object van de klasse
getallen = x_to_the_power_n(x,n)
# Maak een iterabel
iter_obj = iter(getallen)
proberen:
ik = 0
terwijl ik < n-1):
# Haal de volgende waarde op met de methode next()
volgende(iter_obj)
i+=1
print("\n%d tot de macht %d is %d" %(x,n,iter_obj.__De volgende__()))
behalve StopIteratie:
# Beëindig het script als er geen waarde bestaat
print(volgende(iter_obj))

Uitgang:

De volgende uitvoer laat zien dat: 2 wordt genomen als de waarde van X en 4 wordt genomen als de waarde van nee. Dus het script berekende de waarde van 2⁴  zijn 16.

Voorbeeld 5: Gebruik van een oneindige aangepaste iterator

Het volgende script drukt continu de getallen af ​​die deelbaar zijn door 5 met een vertraging van één seconde totdat de gebruiker op . drukt Ctrl + c genereren van de 'Toetsenbordonderbreking' signaal'. Het oneindige 'terwijl' loop wordt hier gebruikt om een ​​oneindige aangepaste iterator te maken. De 'tijd' module wordt aan het begin van het script geïmporteerd om de 'slaap()' methode om elke output een seconde te vertragen. Het cijfer 5 wordt geïnitialiseerd op de 'aantal' variabele als het eerste deelbare getal in het script, en het volgende getal wordt gegenereerd door 5 toe te voegen aan de vorige waarde van de 'aantal'variabele'.

# Tijdmodule importeren
import tijd
"
Maak een klas om de getallen te genereren
die continu deelbaar zijn door 5
"
class Number_Deelbaar_door_vijf:
# Initialiseer de waarde van num
def __iter__(zelf):
zelf.aantal = 5
zelf terugkeren
# Bereken het volgende getal dat deelbaar is door 5
def __volgende__(zelf):
next_num = zelf.aantal
tijd.slapen(1)
zelf.aantal += 5
return next_num
# Maak een object van de klasse
Object = Getal_Deelbaar_door_vijf()
# Maak een itereerbaar object
iterObject = iter(Object)
# Definieer oneindige lus
terwijl waar:
proberen:
# Ga voor de volgende iteratie
print(iterObject).__De volgende__())
behalve KeyboardInterrupt:
print("Ctrl+C is ingedrukt.")
# Beëindig de lus wanneer Ctrl+C wordt ingedrukt
breken

Uitgang:

De volgende uitvoer laat zien dat het nummer begon met afdrukken vanaf 5 en continu de volgende nummers na elkaar afdrukte met een duur van één secondesecond. Toen de gebruiker op . drukte Ctrl + c na het afdrukken van het nummer 60, de boodschap 'Ctrl+C is ingedrukt.' werd afgedrukt, voordat het script werd beëindigd.

Voorbeeld 6: Een aangepaste oneindige iterator besturen

Het volgende script laat zien hoe u de aangepaste oneindige iterator kunt stoppen na het voltooien van een opgegeven aantal iteraties. De '__iter__()' methode van de klasse initialiseert de waarden van de 'nee' en 'resultaat' klasse variabelen. Het script berekent de kwadraten van de getallen, beginnend bij 1, die zijn opgeslagen in de variabele nee, en print de vierkante waarde van nee tot de waarde van nee is groter dan 5. Een oneindige while-lus wordt hier gedeclareerd om de ' aan te roepen__De volgende__()' methode om de kwadratische waarde van . af te drukken nee. Wanneer de waarde van nee bereikt 6, de 'StopIteratie' signaal zal genereren om de lus te beëindigen.

# Tijdmodule importeren
import tijd
"
Maak een klas om te berekenen
het kwadraat van het getal begint van 1 tot
de waarde van het getal is kleiner dan 6
"
klasse berekenen_vermogen:
# Initialiseer de waarde van num
def __iter__(zelf):
zelf.n = 1
zelf.resultaat=0
zelf terugkeren
# Bereken het volgende getal dat deelbaar is door 5
def __volgende__(zelf):
# Controleer of de waarde van n kleiner is dan of gelijk is aan 5 of niet
als zelf.nee <= 5:
zelf.resultaat = zelf.n**2
tijd.slaap (0.5)
zelf.n += 1
zelf terugkeren.resultaat
anders:
Verhoog StopIteratie
# Maak een object van de klasse
Object = bereken_kracht()
# Maak een itereerbaar object
iterObject = iter(Object)
# Definieer oneindige lus
terwijl waar:
proberen:
# Ga voor de volgende iteratie en druk de vierkante waarde af
print("Het vierkant van %d is %d" %(iterObject.n,iterObject.__De volgende__()))
behalve StopIteratie:
print("\nBeëindigd uit de lus.")
# Beëindigen van de lus
breken

Uitgang:

De volgende uitvoer laat zien dat de oneindige aangepaste iterator werd beëindigd toen de waarde van n groter werd dan 5. Het script berekende en printte de vierkante waarden van de getalwaarden van 1 tot 5.

Itereren met itertools

Python heeft een ingebouwde module met de naam 'itertools' die kan worden gebruikt om een ​​iterator te maken voor het herhalen van gegevens met behulp van een lus. Het volgende gedeelte van dit artikel laat zien hoe u drie functies in deze module kunt gebruiken.

itertools.tel()

De 'itertools'.vervolg' functie kan worden gebruikt met de 'kaart()' methode om sequentiële gegevens te genereren en met de 'zip()' methode om reeksen toe te voegen met behulp van de count parameter van deze methode. De syntaxis van deze functie wordt hieronder gegeven:.

Syntaxis

itertools.tellen (start=0, stap=1)

Hier, de eerste parameter, 'begin,' wordt gebruikt om de startwaarde van de reeks te definiëren, en 0 is de standaardwaarde van deze parameter. De tweede parameter, 'stap,' wordt gebruikt om het verschil tussen de opeenvolgende nummers in te stellen, en 1 is de standaardwaarde van deze parameter.

Voorbeeld 7: Gebruik van count() Functie van itertools

Het volgende script berekent de som van: 0 naar nee getallen, waarbij de waarde van nee wordt overgenomen van de gebruiker. De 'tel()' functie is geïmporteerd uit 'itertools' aan het begin van het script. De 'mijn_iterator' object wordt geïnitialiseerd met de 'tel()' functie, met een 'begin' waarde van 0 en een 'stap' waarde van 1. Vervolgens de 'sum_result' variabele wordt geïnitialiseerd door de eerste waarde van het itereerbare object. De startwaarde wordt geïnitialiseerd op de variabele ik en het startnummer wordt opgeslagen als het teken in de variabele, getallen die worden gebruikt om andere getallen in elke iteratie te combineren combine. De waarden van de volgnummers worden in elke iteratie opgeteld wanneer de 'De volgende()' methode heet. Wanneer de waarde van ik wordt groter dan nee, het script wordt beëindigd door het resultaat van de som weer te geven.

"Het volgende script berekent
de som van 0 tot het getal dat als invoer wordt genomen.
"
# Importtelling
van itertools import tellen
# Creëert een itereerbaar object van count()
my_iterator = count(start=0, step=1)
# Lees de eerste waarde van de iterator
sum_result = volgende(mijn_iterator)
# Voer een nummer in om de oneindige while-lus te beëindigen
n = int(input("Vul de grenswaarde in:"))
# Initialiseer de waarde van i en getallen
ik = som_resultaat
getallen = f'i'
# Declareer oneindige lus
terwijl waar:
# Voeg het nummer toe in elke iteratie
sum_result += i
ik = volgende(mijn_iterator)
# Beëindig de lus als de waarde van i groter is dan n
als (i > n):
breken
# Voeg de getalwaarde toe als een tekenreeks met het '+'-symbool
cijfers += "+" + f'i'
# Print de uiteindelijke waarde
print("%s = %d" % (getallen,som_resultaat))

Uitgang:

De volgende uitvoer laat zien dat het nummer 10 wordt gebruikt als invoer voor het beëindigen van de lus na het uitvoeren van het script. In deze uitvoer heeft het script de som van 0 tot 10 berekend en de uitvoer afgedrukt, 0+1+2+3+4+5+6+7+8+9+10 = 55.

Itertools.fiets()

Deze functie bevat slechts één argument, dat elk object kan zijn. Het doel van deze functie is om de waarden van het object te herhalen na het voltooien van de iteratie van alle waarden. Hier, strings, tupels, lijsten, enz. kan worden gebruikt als een object. De itereerbare objectretouren van deze functie worden gebruikt om elke waarde van het object dat als argument wordt gebruikt, te herhalen met behulp van de 'De volgende()' methode'. Het aantal keren dat de waarden van het itereerbare object worden herhaald, is gebaseerd op het aantal herhalingen van de lus. De syntaxis van deze functie wordt hieronder gegeven:.

Syntaxis

itertools.cyclus (Object)

Voorbeeld 8: Gebruik van cycle() Functie van itertools

De 'willekeurig' en 'itertools' modules worden aan het begin van het script geïmporteerd om een ​​willekeurig getal te genereren en om de 'fiets()' functie van de  'itertools' module voor het herhalen van de gegevens. Een lijst van drie willekeurige getallen wordt gebruikt als argument van de 'fiets()' functie'. Het itereerbare object met de naam 'aantal_lijst' wordt geïnitialiseerd door de retourwaarde van deze functie. De 'tellen' variabele wordt geïnitialiseerd op 0, en wanneer de waarde van deze variabele wordt 6, de 'terwijl' lus zal eindigen. Dus de 'terwijl' lus wordt zes keer herhaald en elke waarde van de lijst wordt slechts één keer herhaald.

# Import willekeurige module
willekeurig importeren
# Itertools-module importeren
itertools importeren
# Genereer een itereerbaar object op basis van de lijst met drie willekeurige getallen
num_list = itertools.cyclus([willekeurige.randint(1,5),willekeurig.randint (10,50), willekeurig.randint
(100.500)] )
# Initialiseer de teller
aantal = 0
# Herhaal de lus 6 keer
terwijl (tel != 6):
print('Het huidige willekeurige getal is: ' + f'next(num_list)')
tel+=1

Uitgang:

De volgende uitvoer laat zien dat drie willekeurige getallen, 3, 17, en 185, zijn gegenereerd als lijstitems. De lus wordt zes keer herhaald en deze drie waarden worden herhaald voor de volgende herhalingen.

Itertools.herhaling()

De functie 'repeat()' werkt als een oneindige iterator en kan twee argumenten aannemen. Wanneer het tweede argument wordt weggelaten, werkt de functie 'repeat()' als een oneindige iterator en herhaalt de waarde een oneindig aantal keren. Deze functie neemt geen geheugen voor elke herhaling in beslag. Het maakt de variabele slechts één keer in het geheugen aan en herhaalt dezelfde variabele een oneindig aantal keren wanneer er slechts één argument voor deze functie is ingesteld. De syntaxis van deze functie wordt hieronder gegeven:.

Syntaxis

itertools.herhaal(waarde, limiet)

Het eerste argument wordt gebruikt om de waarde aan te nemen die zich zal herhalen. Het tweede argument is optioneel en wordt gebruikt om de limiet van herhalingen in te stellen.

Voorbeeld 9: Gebruik van repeat() Functie van itertools Module

De 'itertools' module wordt aan het begin van het script geïmporteerd om de 'herhaling()' functie'. Er wordt een tekenreekswaarde van de gebruiker genomen om te herhalen en een numerieke waarde wordt van de gebruiker genomen om de herhaallimiet in te stellen. De retourwaarde van de 'herhaling()' functie wordt dan omgezet in een lijst met de 'lijst()' methode en opgeslagen in de 'lijstgegevens'variabele'. De waarden van de 'lijstgegevens' wordt afgedrukt met de 'voor'lus'.

# Itertools-module importeren
itertools importeren
# Neem de invoerwaarde die wordt herhaald
string = input("Vul een string in: ")
# Neem de nummerwaarde om te herhalen
repeat = int(input("Voer het te herhalen getal in: "))
# gebruik repeat() om de string herhaaldelijk aan een lijst toe te voegen
listData= lijst(itertools.herhalen(string, herhalen))
# Initialiseer i
ik = 1
print ("De lijstwaarden zijn: \n")
# Herhaal de lijst met de for-lus
voor val in listData:
print("Lijstitem %d =%s" %(i,val))
ik += 1

Uitgang:

De volgende uitvoer laat zien dat 'Python' wordt genomen als de tekenreekswaarde, en 3 wordt genomen als het nummer dat wordt gebruikt om de tekenreekswaarde te herhalen na het uitvoeren van het script. De uitvoer laat zien dat de string 'Python' wordt drie keer herhaald.

Conclusie

Het concept van iterator en het gebruik van verschillende soorten iterators in Python wordt geprobeerd uit te leggen met de zeer eenvoudige voorbeelden in dit artikel. Python-gebruikers kunnen een ingebouwde iterator gebruiken of hun aangepaste iterator maken op basis van de vereiste. Dit artikel helpt de python-gebruikers om meer te weten te komen over de methoden die in de iterator worden gebruikt en hoe deze methoden werken met elke lus om elk itereerbaar object te lezen. Sommige toepassingen van itertools module van python worden ook uitgelegd in dit artikel om meer details te weten over de iterator in python.