Python Academy · Lektion

Das Iterator-Protokoll

__iter__ und __next__ verstehen

Das Iterator-Protokoll ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Iteration?

Immer wenn Sie eine for-Schleife über eine Liste, Zeichenkette oder ein dict schreiben, verwendet Python im Hintergrund das Iteratorprotokoll.

Ein Objekt, das Sie in einer Schleife durchlaufen können, wird als iterierbar bezeichnet. Das Objekt, das tatsächlich nacheinander einzelne Werte erzeugt, wird als Iterator bezeichnet.

for ch in 'abc':
    print(ch)

iter() und next()

Zwei integrierte Funktionen steuern die Iteration:

iter(obj) fordert von einem iterierbaren Objekt seinen Iterator an.
next(it) fordert vom Iterator den nächsten Wert an.

Wenn keine weiteren Werte vorhanden sind, löst next() StopIteration aus.

it = iter([10, 20, 30])
print(next(it))
print(next(it))
print(next(it))

StopIteration

Wenn Sie next() einmal zu oft aufrufen, wird StopIteration ausgelöst. Eine for-Schleife fängt dies automatisch ab und beendet sich sauber.

it = iter([1])
print(next(it))
try:
    next(it)
except StopIteration:
    print('No more items')

Die beiden Dunder-Methoden

Um einen eigenen Iterator zu erstellen, implementieren Sie zwei Methoden:

__iter__ gibt das Iteratorobjekt selbst zurück.
__next__ gibt den nächsten Wert zurück oder löst StopIteration aus.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

for x in Count(3):
    print(x)

Iterierbares Objekt und Iterator im Vergleich

Ein iterierbares Objekt benötigt nur __iter__. Ein Iterator benötigt sowohl __iter__ als auch __next__.

Listen sind iterierbar, aber keine Iteratoren: Jeder Aufruf von iter() liefert einen neuen Iterator.

nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(it is iter(it))

Iteratoren sind nach einmaliger Verwendung erschöpft

Ein Iterator kann nur einmal durchlaufen werden. Sobald Sie das Ende erreicht haben, bleibt er leer. Um erneut zu iterieren, erstellen Sie einen neuen Iterator.

it = iter([1, 2])
print(list(it))
print(list(it))

Ein Iterator ähnlich wie range

Erstellen wir einen benutzerdefinierten Iterator, der sich wie ein einfacher Zähler verhält. Beachten Sie, dass der Zustand in der Instanz gespeichert wird.

class EvenUpTo:
    def __init__(self, limit):
        self.cur = 0
        self.limit = limit
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur > self.limit:
            raise StopIteration
        value = self.cur
        self.cur += 2
        return value

print(list(EvenUpTo(8)))

Iterierbares Objekt und Iterator trennen

Ein übersichtlicheres Design hält den Container und den Iterator getrennt, sodass der Container mehrfach durchlaufen werden kann.

class Bag:
    def __init__(self, items):
        self.items = items
    def __iter__(self):
        return BagIterator(self.items)

class BagIterator:
    def __init__(self, items):
        self.items = items
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= len(self.items):
            raise StopIteration
        v = self.items[self.i]
        self.i += 1
        return v

b = Bag(['x', 'y'])
print(list(b))
print(list(b))

next() mit einem Standardwert verwenden

next(it, default) gibt den Standardwert zurück, anstatt StopIteration auszulösen, wenn der Iterator leer ist. Das ist praktisch, um sicher den nächsten Wert zu prüfen.

it = iter([42])
print(next(it, 'done'))
print(next(it, 'done'))

Iteratoren schonen den Speicher

Iteratoren liefern jeweils ein Element, sodass sie nicht die gesamte Sequenz im Speicher halten müssen. Deshalb eignen sie sich auch für sehr große oder sogar unendliche Datenströme.

class Naturals:
    def __init__(self):
        self.n = 0
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n

it = iter(Naturals())
print(next(it), next(it), next(it))

Eingebaute Funktionen, die Iteratoren verbrauchen

Viele eingebaute Funktionen akzeptieren beliebige Iteratoren: sum, max, min, sorted, list, tuple. Sie lesen Werte ein, bis StopIteration auftritt.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

print(sum(Count(5)))
print(max(Count(5)))

Kurzer Test

Testen Sie Ihr Verständnis des Iterator-Protokolls.

Zusammenfassung

Sie haben das Iterator-Protokoll kennengelernt:

iter() ruft einen Iterator ab; next() ruft Werte ab.
StopIteration signalisiert das Ende, und for behandelt es.
Benutzerdefinierte Iteratoren implementieren __iter__ und __next__.
Iteratoren sind nur einmal verwendbar und gehen sparsam mit Speicher um.

Als Nächstes lassen Sie Python mit yield Iteratoren für Sie schreiben.

Häufig gestellte Fragen

Ist die Lektion „Das Iterator-Protokoll“ kostenlos?

Ja — der vollständige Text von „Das Iterator-Protokoll“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Das Iterator-Protokoll“?

__iter__ und __next__ verstehen Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Das Iterator-Protokoll“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy