Benutzerdefinierter Python-Iterator

1. Erstellen Sie einen benutzerdefinierten Iterator mit Hilfe der Klassenmethoden __iter__ und __next__ in Python
2. Erstellen Sie einen benutzerdefinierten Iterator mit Hilfe eines Generators in Python

In diesem Artikel lernen wir, was Iteratoren sind und wie man mit Hilfe der Klassenmethoden namens __iter__ und __next__ einen benutzerdefinierten Iterator erstellt. Wir werden auch lernen, wie man mit Hilfe eines Generators in Python einen benutzerdefinierten Iterator erstellt.

Erstellen Sie einen benutzerdefinierten Iterator mit Hilfe der Klassenmethoden __iter__ und __next__ in Python

Wenn Sie jetzt Iterator sagen, wird es, wie der Name schon sagt, für Iterationen verwendet.

Wenn Sie aus Sprachen wie C, C++ und Java kommen, haben wir ein gemeinsames Konzept: ++. Ein weiteres Konzept ist bekannt, wenn wir über Iterationen sprechen: die for-Schleife.

Nehmen wir an, wir haben eine Liste mit 5 Elementen. Mit einer Schleife können wir vom ersten Element zum letzten Element iterieren.

Auf diese Weise haben wir eine Liste mit einigen Werten, und wenn wir sie einzeln drucken möchten, verwenden wir die Indexnummern.

Wenn wir unseren Index 0 übergeben, erhalten wir das erste Element, 2. Wenn wir den Indexwert 1 verwenden, erhalten wir das zweite Element, 5.

Numbers = [2, 5, 10, 3, 1]

print(Numbers[0])
print(Numbers[1])

Ausgang:

2
5

Die andere Möglichkeit, die Werte zu drucken, ist die Verwendung einer Schleife. Wir können eine Liste durchlaufen und alle Werte drucken.

Numbers = [2, 5, 10, 3, 1]

for i in Numbers:
    print(i)

Ausgang:

2
5
10
3
1

Jetzt haben wir einen weiteren Weg: durch die Verwendung eines Iterators. Im Allgemeinen arbeitet ein Iterator hinter den Kulissen der for-Schleife.

Wir werden eine iter()-Funktion verwenden, um einen Iterator zu verstehen, der unsere Liste in einen Iterator umwandelt. Dieser Iterator gibt uns nicht alle Werte; es wird jeweils nur ein Wert ausgegeben.

Numbers = [2, 5, 10, 3, 1]

ITR = iter(Numbers)
print(ITR)

Wir können sehen, dass es das Objekt eines Iterators druckt.

<list_iterator object at 0x000001FEDCFF7310>

Aber wenn Sie den Wert wollen, können Sie ITR.__next__() setzen, was eine eingebaute Methode ist. Es gibt uns den ersten Wert beim ersten Aufruf der Methode __next__() für ein bestimmtes Objekt; Auf dieselbe Weise haben wir den Indexwert verwendet, aber der Vorteil ist, dass wir den Indexwert nicht verwenden müssen.

umbers = [2, 5, 10, 3, 1]

ITR = iter(Numbers)
print(ITR.__next__())

Ausgang:

2

Es wird den nächsten Wert geben, wenn wir ITR.__next__() in der nächsten Ausführungszeile ausführen. Hinter dieser Szene hat der Iterator mehrere Werte, wenn wir also die Methode __next__() aufrufen, nimmt er einen Wert auf.

Und wieder, wenn wir __next__() aufrufen, kennt es den letzten Wert von i, was bedeutet, dass es den Zustand des letzten Werts beibehält. Das ist das Schöne an Iterator; Wenn wir die Funktion erneut aufrufen, behält sie den alten Wert bei.

Wir können unseren Iterator mit einer Klasse erstellen. Über die Klasse können wir die Top 10 Werte einzeln ausdrucken.

Um dies zu erreichen, haben wir eine Klasse namens TopValues, und in dieser Klasse werden wir einen Zähler spezifizieren.

Und dafür verwenden wir die Funktion __init__, wo wir unsere Zählervariable self.N=1 definieren; Offensichtlich wird der Zähler von 1 aus initialisiert. Wir benötigen zwei wichtige Methoden, um unseren benutzerdefinierten Iterator zu erstellen.

Die erste ist die iter()-Methode, die uns das Objekt des Iterators liefert, und dann liefert die next()-Methode den nächsten Wert oder das nächste Objekt. In der Methode __next__ verwenden wir anstelle der Rückgabe von self.N eine Variable namens VALUE, in der wir self.N zuweisen, und in der nächsten Zeile erhöhen wir self.N um eins .

Damit wird es bei jeder nächsten Iteration inkrementiert und gibt dann den VALUE zurück, nicht self.N, weil self.N für die nächste Iteration inkrementiert wird.

class TopValues:
    def __init__(self):
        self.N = 1

    def __iter__(self):
        return self

    def __next__(self):
        VALUE = self.N
        self.N += 1
        return VALUE

Unser Iterator ist nun bereit, damit wir ein Objekt der Klasse TopValues erstellen können. Lassen Sie uns eine Schleife verwenden, denn normalerweise können wir Schleifen verwenden, wenn Sie einen Iterator haben.

T_Val = TopValues()

for i in T_Val:
    print(i)

Wenn wir nun diesen Code ausführen, erhalten wir Tausende von Werten.

1
2
3
4
5
....
1000

Versuchen wir zu verstehen, was passiert. Um zu überprüfen, ob der Iterator funktioniert, verwenden wir __next__().

print(T_Val.__next__())

Diese Zeile gibt den ersten Iterationswert 1 aus, aber was läuft bei der Schleife schief? Das Problem ist, dass die Schleife von Anfang bis Ende geht; Wir nahmen an, dass das Ende 10 sein würde, aber wir haben nicht erwähnt, wo wir aufhören sollten.

Wenn wir eine Schleife verwenden, ruft sie die Funktion next() auf, wie sie funktioniert. Die for-Schleifen verwenden intern die Funktion next(); Daher wird diese next()-Funktion immer wieder aufgerufen.

Wir müssen eine Bedingung innerhalb der Methode __next__ anwenden.

Wir müssen auch den else-Block setzen; Innerhalb dieses Blocks lösen wir eine Ausnahme aus. Andernfalls druckt die Schleife nach dem Drucken von 10 Werten None-Werte.

class TopValues:
    def __init__(self):
        self.N = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.N <= 10:
            VALUE = self.N
            self.N += 1
            return VALUE
        else:
            raise StopIteration


T_Val = TopValues()

for i in T_Val:
    print(i)

Ausgang:

1
2
3
4
5
6
7
8
9
10

Erstellen Sie einen benutzerdefinierten Iterator mit Hilfe eines Generators in Python

Versuchen wir nun, eine Generatorfunktion zu erstellen, die dasselbe tut. Generatoren sind viel einfacher, da sie die Methoden __iter__() und __next__() für uns erledigen.

Wenn wir versuchen, eine Generatorfunktion namens Our_Gen() zu schreiben, übergeben wir den Parameter innerhalb dieser Funktion.

Da wir die Liste durchlaufen, geben wir jeweils ein Element zurück. Und wenn keine Elemente mehr zum Schleifen vorhanden sind, kümmert es sich automatisch darum und löst eine Ausnahme für das Stoppen der Iteration aus.

Jetzt durchlaufen wir die Funktion Our_Gen(), sodass sie jeweils ein Element ausgeben sollte. Wenn wir das ausführen, können wir sehen, dass wir einen nach dem anderen erhalten.

def Our_Gen(n_list):
    for i in n_list:
        yield i


Func = Our_Gen([2, 5, 10, 3, 1])

for i in Func:
    print(i)

Ausgang:

2
5
10
3
1

Um sicherzustellen, dass unsere next()-Funktion noch funktioniert. Nach der Ausführung erhalten wir fünf Elemente, wir erhalten eine Ausnahme zum Beenden der Iteration.

def Our_Gen(n_list):
    for i in n_list:
        yield i


Func = Our_Gen([2, 5, 10, 3, 1])

print(Func.__next__())
print(Func.__next__())
print(Func.__next__())
print(Func.__next__())
print(Func.__next__())
print(Func.__next__())

Ausgang:

2
5
10
3
1
Traceback (most recent call last):
  File "c:\Users\Dell\Desktop\demo\demo.py", line 56, in <module>
    print(Func.__next__())
StopIteration

Die Generatoren sind einfacher zu schreiben als Klassen. Abhängig von Ihrem Anwendungsfall müssen Sie jedoch möglicherweise wissen, wie die Methoden __iter__() und __next__() in einer Klasse ausgeführt werden.

Weitere Informationen zum Erstellen eines benutzerdefinierten Iterators finden Sie hier.