Python-Iteratoren

Iteratoren sind Objekte, die iteriert werden können. In diesem Tutorial lernen Sie, wie der Iterator funktioniert und wie Sie Ihren eigenen Iterator mit den Methoden __iter__ und __next__ erstellen können.

Video:Python-Iteratoren

Iteratoren in Python

Iteratoren sind überall in Python. Sie sind elegant in for implementiert Loops, Comprehensions, Generatoren etc., sind aber vor aller Augen verborgen.

Iterator in Python ist einfach ein Objekt, das iteriert werden kann. Ein Objekt, das Daten Element für Element zurückgibt.

Technisch gesehen ein Python-Iterator-Objekt muss zwei spezielle Methoden implementieren, __iter__() und __next__() , zusammenfassend als Iteratorprotokoll bezeichnet .

Ein Objekt wird iterierbar genannt wenn wir daraus einen Iterator bekommen können. Die meisten eingebauten Container in Python wie:list, tuple, string etc. sind iterables.

Die iter() Funktion (die wiederum die __iter__() aufruft Methode) gibt einen Iterator von ihnen zurück.

Durch einen Iterator iterieren

Wir verwenden den next() Funktion zum manuellen Durchlaufen aller Elemente eines Iterators. Wenn wir das Ende erreichen und keine weiteren Daten zurückzugeben sind, wird StopIteration ausgelöst Ausnahme. Nachfolgend ein Beispiel.

# define a list
my_list = [4, 7, 0, 3]

# get an iterator using iter()
my_iter = iter(my_list)

# iterate through it using next()

# Output: 4
print(next(my_iter))

# Output: 7
print(next(my_iter))

# next(obj) is same as obj.__next__()

# Output: 0
print(my_iter.__next__())

# Output: 3
print(my_iter.__next__())

# This will raise error, no items left
next(my_iter)

Ausgabe

4
7
0
3
Traceback (most recent call last):
  File "<string>", line 24, in <module>
    next(my_iter)
StopIteration

Eine elegantere Art der automatischen Iteration ist die Verwendung der for-Schleife. Damit können wir über jedes Objekt iterieren, das einen Iterator zurückgeben kann, z. B. Liste, String, Datei usw.

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

Arbeiten der for-Schleife für Iteratoren

Wie wir im obigen Beispiel sehen, ist die for Schleife konnte die Liste automatisch durchlaufen.

Genauer gesagt die for Schleife kann über jede iterierbare Schleife iterieren. Schauen wir uns genauer an, wie die for Schleife ist tatsächlich in Python implementiert.

for element in iterable:
    # do something with element

Ist eigentlich implementiert als.

# create an iterator object from that iterable
iter_obj = iter(iterable)

# infinite loop
while True:
    try:
        # get the next item
        element = next(iter_obj)
        # do something with element
    except StopIteration:
        # if StopIteration is raised, break from loop
        break

Also intern die for Schleife erstellt ein Iterator-Objekt, iter_obj durch Aufruf von iter() auf dem Iterierbaren.

Ironischerweise dieser for Schleife ist eigentlich eine unendliche While-Schleife.

Innerhalb der Schleife wird next() aufgerufen um das nächste Element zu erhalten und führt den Körper von for aus Schleife mit diesem Wert. Nachdem alle Gegenstände erschöpft sind, StopIteration angehoben wird, die innen gefangen wird und die Schlaufe endet. Beachten Sie, dass alle anderen Arten von Ausnahmen durchgelassen werden.

Benutzerdefinierte Iteratoren erstellen

Das Erstellen eines Iterators von Grund auf ist in Python einfach. Wir müssen nur den __iter__() implementieren und die __next__() Methoden.

Die __iter__() -Methode gibt das Iteratorobjekt selbst zurück. Bei Bedarf können einige Initialisierungen durchgeführt werden.

Der __next__() -Methode muss das nächste Element in der Sequenz zurückgeben. Beim Erreichen des Endes und bei nachfolgenden Aufrufen muss StopIteration ausgegeben werden .

Hier zeigen wir ein Beispiel, das uns in jeder Iteration die nächste Potenz von 2 liefert. Der Potenzexponent beginnt bei Null bis zu einer vom Benutzer festgelegten Zahl.

Wenn Sie keine Ahnung von objektorientierter Programmierung haben, besuchen Sie Python Object-Oriented Programming.

class PowTwo:
    """Class to implement an iterator
    of powers of two"""

    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


# create an object
numbers = PowTwo(3)

# create an iterable from the object
i = iter(numbers)

# Using next to get to the next iterator element
print(next(i))
print(next(i))
print(next(i))
print(next(i))
print(next(i))

Ausgabe

1
2
4
8
Traceback (most recent call last):
  File "/home/bsoyuj/Desktop/Untitled-1.py", line 32, in <module>
    print(next(i))
  File "<string>", line 18, in __next__
    raise StopIteration
StopIteration

Wir können auch einen for verwenden Schleife, um über unsere Iteratorklasse zu iterieren.

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

Python Unendliche Iteratoren

Es ist nicht erforderlich, dass das Element in einem Iteratorobjekt erschöpft sein muss. Es kann unendlich viele Iteratoren geben (die niemals enden). Wir müssen beim Umgang mit solchen Iteratoren vorsichtig sein.

Hier ist ein einfaches Beispiel, um unendliche Iteratoren zu demonstrieren.

Die eingebaute Funktion iter() kann mit zwei Argumenten aufgerufen werden, wobei das erste Argument ein aufrufbares Objekt (Funktion) und das zweite der Wächter sein muss. Der Iterator ruft diese Funktion auf, bis der zurückgegebene Wert gleich dem Sentinel ist.

>>> int()
0

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

Wir können sehen, dass der int() Die Funktion gibt immer 0 zurück. Sie wird also als iter(int,1) übergeben gibt einen Iterator zurück, der int() aufruft bis der zurückgegebene Wert gleich 1 ist. Dies passiert nie und wir erhalten einen unendlichen Iterator.

Wir können auch unsere eigenen unendlichen Iteratoren bauen. Der folgende Iterator gibt theoretisch alle ungeraden Zahlen zurück.

class InfIter:
    """Infinite iterator to return all
        odd numbers"""

    def __iter__(self):
        self.num = 1
        return self

    def __next__(self):
        num = self.num
        self.num += 2
        return num

Ein Beispiellauf wäre wie folgt.

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

Und so weiter...

Achten Sie darauf, eine Beendigungsbedingung einzuschließen, wenn Sie über diese Arten von unendlichen Iteratoren iterieren.

Der Vorteil der Verwendung von Iteratoren besteht darin, dass sie Ressourcen sparen. Wie oben gezeigt, könnten wir alle ungeraden Zahlen erhalten, ohne das gesamte Zahlensystem im Speicher zu speichern. Wir können (theoretisch) unendlich viele Elemente im endlichen Speicher haben.

Es gibt eine einfachere Möglichkeit, Iteratoren in Python zu erstellen. Um mehr zu erfahren, besuchen Sie:Python-Generatoren mit Yield.

Überladen von Python-Operatoren Python-Generatoren

Python