Iteratoren in Python

Iteratoren sind iterierbare Objekte. In diesem教程, werden Sie das Funktionieren von Iteratoren sowie wie man eigene Iteratoren mit den __iter__ und __next__-Methoden erstellt, lernen.

Was ist ein Iterator in Python?

Iteratoren sind in Python überall. Sie werden elegant in for-Loops, comprehensions, Generatoren usw. implementiert, aber versteckt unter der Oberfläche.

Ein Iterator in Python ist nur ein iterierbaresObjekt. Ein Objekt, das Daten zurückgibt, ein Element nach dem anderen.

Technisch gesehen, gibt es in Python Iteratorenobjektemüssen zwei besondere Methoden implementiert werden, __iter__() und __next__(), die zusammen alsIteratorenprotokoll.

Wenn wir Iteratoren von einem Objekt erhalten können, dann wird dieses Objekt alsiterierbariterieren. Die meisten eingebauten Container in Python (z.B.):list,tuple,stringu.a.) sind iterierbar.

Die Funktion iter() (oder das __iter__() -Verfahren) gibt Iteratoren von ihnen zurück.

Durch Iteratoren in Python iterieren

Wir verwenden die next()-Funktion, um manuell alle Projekte des Iterators zu durchlaufen. Wenn wir am Ende angelangt sind und keine weiteren Daten zurückgegeben werden müssen, wird StopIteration ausgelöst. Ein Beispiel ist wie folgt...

# Eine Liste definieren
my_list　=　[4,　7, 0,　3]
# Mit iter() Iteratoren erhalten
my_iter　=　iter(my_list)
## Mit iter() Iteratoren erhalten　
# Ausgabe　4
print(next(my_iter))
# Ausgabe　7
print(next(my_iter))
## next（obj）und obj　.__　next　__() sind gleich
# Ausgabe 0
print(my_iter.__next__())
# Ausgabe　3
print(my_iter.__next__())
## Dies verursacht einen Fehler, da keine Projekte mehr übrig sind
next(my_iter)

Eine elegantere Methode zur automatischen Iteration ist die Verwendung vonfor-LoopMit diesem Verfahren können wir alle Objekte durchlaufen, die Iteratoren zurückgeben können, wie z.B. Listen, Strings, Dateien usw.

>>>  for  element  in  my_list:
...    print(element)
...　　　　　
4
7
0
3

Wie funktioniert der for-Loop tatsächlich?

Wie wir im obigen Beispiel sehen können, kann der for-Loop automatisch durch Listen iterieren.

Tatsächlich kann der for-Loop alle iterierbaren Objekte durchlaufen. Lassen Sie uns genauer sehen, wie der for-Loop in Python tatsächlich einen Loop implementiert.

for　element　in　iterable:
　　　　#　Mit dem Element etwas tun

wird tatsächlich implementiert.

#　Erstellen eines Iteratorkindes iterable
iter_obj　=　iter(iterable)
#　Unendliche Schleife
while　True:
　　　　try:
　　　　　　　　#　Nächstes Element holen
　　　　　　　　element　=　next(iter_obj)
　　　　　　　　#　Mit dem Element etwas tun
　　　　except　StopIteration:
　　　　　　　　#　Wenn StopIteration ausgelöst wird, wird der Schleifenabbruch erreicht
　　　　　　　　break

Daher erstellt der for-Schleife intern durch Aufruf von iter() auf das iterable ein Iteratorkind iter_obj.

Ironischerweise ist dieser for-Schleife tatsächlich unendlichwhile-Schleife.

Innerhalb des Schleifenkörpers ruft es next() auf, um das nächste Element zu erhalten und dieses Wert im Hauptkörper des for-Schleifen zu verwenden. Wenn alle Elemente abgearbeitet sind, wird StopIteration ausgelöst, die intern erfasst wird und der Schleifenende erreicht wird. Beachten Sie, dass alle anderen Arten von Ausnahmen durchgelassen werden.

Mit Python eigenen Iterator zu erstellen

Es ist in Python einfach, Iteratoren von Grund auf zu erstellen. Wir müssen nur diese Methoden __iter__() und __next__() implementieren.

__iter__() muss das Iteratorkind selbst zurückgeben. Optional können einige Initialisierungen durchgeführt werden.

__next__() muss das nächste Element der Sequenz zurückgeben. Bei Erreichen des Endes sowie in nachfolgenden Aufrufen muss StopIteration ausgelöst werden.

Hier zeigen wir ein Beispiel, das uns in jeder Iteration eine2Doppelpotenz. Die Potenzexponenten reichen von 0 bis zur vom Benutzer festgelegten Zahl.

class　PowTwo:
　　　　"""Implementierung der Iteratorklasse
　　　　　　　　　　　　　Doppelpotenz"""
　　　　def　__init__(self,　max　=　0):
　　　　　　　　self.max　=　max
　　　　def __iter__(self):
　　　　　　　　self.n　=　0
　　　　　　　　return self
　　　　def __next__(self):
　　　　　　　　if　self.n　<=　self.max:
　　　　　　　　　　　　result　=　2　**　self.n
　　　　　　　　　　　　self.n　+=　1
　　　　　　　　　　　　return　result
　　　　　　　　else:
　　　　　　　　　　　　raise　StopIteration

Nun können wir einen Iterator erstellen und wie folgt iterieren.

>>>　a　=　PowTwo(4)
>>>　i　=　iter(a)
>>>　next(i)
1
>>>　next(i)
2
>>>　next(i)
4
>>>　next(i)
8
>>>　next(i)
16
>>>　next(i)
Traceback　(most　recent　call　last):
...
StopIteration

Wir können auch einen for-Schleife verwenden, um die Iteratorklasse zu iterieren.

>>>　for　i　in　PowTwo(5):
...　　　　　print(i)
...　　　　　
1
2
4
8
16
32

Python-unendlicher Iterator

Die Elemente im Iteratorobjekt müssen nicht ausgegeben werden. Es können unendliche Iteratoren geben (niemals enden). Beim Umgang mit solchen Iteratoren müssen wir vorsichtig sein.

Dies ist ein einfaches Beispiel zur Demonstration unendlicher Iteratoren.

Integrierte Funktionen iter() kann mit zwei Parametern aufgerufen werden, wobei der erste Parameter ein aufrufbares Objekt (Funktion) sein muss und der zweite Parameter das Markenzeichen ist. Der Iterator ruft diese Funktion auf, bis der zurückgegebene Wert dem Markenzeichen entspricht.

>>> int()
0
>>> inf = iter(int,1)
>>> next(inf)
0
>>> next(inf)
0

Wir können sehen, dass die Funktion int() immer 0 zurückgibt. Daher wird sie als iter(int,1)Übergabe wird einen Iterator zurückgeben, der int() bis zum Wert zurückgibt, der gleich dem Markenzeichen ist.1. Dies wird niemals passieren, und wir erhalten einen unendlichen Iterator.

Wir können auch unsere eigenen unendlichen Iteratoren erstellen. Theoretisch gibt der folgende Iterator alle ungeraden Zahlen zurück.

class InfIter:
　　　　"""Unendlicher Iterator gibt alle
　　　　　　　　　　　　　　　　　ungerade """
　　　　def __iter__(self):
　　　　　　　　self.num =　1
　　　　　　　　return self
　　　　def __next__(self):
　　　　　　　　num = self.num
　　　　　　　　self.num　+=　2
　　　　　　　　return num

Führen Sie folgenden Befehl aus.

>>> a = iter(InfIter())
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7

...

Seien Sie vorsichtig bei der Verwendung von Endbedingungen bei der Iteration über diese Arten von unendlichen Iteratoren.

Der Vorteil der Verwendung von Iteratoren ist die Ressourcensparnis. Wie gezeigt, können wir alle ungeraden Zahlen erhalten, ohne die gesamte Zahlensystem im Speicher zu speichern. Theoretisch können wir unendlich viele Elemente in begrenztem Speicher enthalten.

Iteratoren machen unseren Code auch cooler aus.

Es gibt eine einfache Methode, Iteratoren in Python zu erstellen. Für weitere Informationen besuchen Sie bitte:Python-Generator yield.