Iterable und Iterator in Python: __iter__ und __next__

Stell dir vor, du schreibst in deiner Prüfungsvorbereitung eine `for`-Schleife über eine Liste - und fragst dich plötzlich: Wie weiß Python eigentlich, was als Nächstes kommt? Woher kommt das `i` in `for i in meine_liste`? Die Antwort liegt in zwei Konzepten, die in fast jedem Python-Code stecken: Iterable und Iterator. Wer die versteht, versteht plötzlich auch Generatoren, `zip()`, `enumerate()` und warum manche Objekte nur einmal durchlaufen werden können.

Was ist ein Iterable in Python?

Ein Iterable ist jedes Objekt, über das du mit einer `for`-Schleife iterieren kannst. Es implementiert die Methode `__iter__()`, die einen Iterator zurückgibt.

Konkret sind das Listen, Tupel, Strings, Dictionaries, Sets oder auch Dateiobjekte. Stell dir ein Iterable wie ein Bücherregal vor: Es enthält alle Bücher, aber es ist nicht der Vorgang des Blätterns. Um zu lesen, brauchst du jemanden, der dir Buch für Buch reicht - und das ist der Iterator.

meine_liste = [10, 20, 30]

# Alles hier sind Iterables:
for zahl in meine_liste:
    print(zahl)

for zeichen in "hallo":
    print(zeichen)

Mit der eingebauten Funktion iter() holst du dir aus jedem Iterable einen Iterator:

meine_liste = [10, 20, 30]
iterator = iter(meine_liste)  # erzeugt einen Iterator
print(iterator)  # <list_iterator object at 0x...>

Merke: Ein Iterable kann dir einen Iterator liefern (`__iter__`). Es weiß aber nicht selbst, an welcher Stelle der Iteration es sich befindet.

Was ist ein Iterator in Python?

Ein Iterator ist ein Objekt, das die beiden Methoden `__iter__()` und `__next__()` implementiert. `__next__()` liefert das nächste Element - und wenn keines mehr da ist, wirft es eine StopIteration-Ausnahme.

Bleiben wir beim Bücherregal: Der Iterator ist die Person, die dir ein Buch nach dem anderen reicht und am Ende sagt: "Das war alles." Python fängt diese StopIteration in der `for`-Schleife automatisch ab, deshalb siehst du sie normalerweise nie.

meine_liste = [10, 20, 30]
iterator = iter(meine_liste)

print(next(iterator))  # 10
print(next(iterator))  # 20
print(next(iterator))  # 30
next(iterator)  # wirft StopIteration

Die Funktion next() ruft intern `iterator.__next__()` auf. Beide Schreibweisen sind identisch - `next()` ist einfach die übliche.

Merke: Ein Iterator ist immer auch ein Iterable (sein `__iter__()` gibt sich selbst zurück). Umgekehrt gilt das nicht - ein Iterable ist nicht automatisch ein Iterator.

Iterable vs. Iterator: Der Unterschied auf einen Blick

Wie funktioniert die for-Schleife intern?

Die `for`-Schleife macht im Hintergrund genau drei Dinge: Sie holt sich mit `iter()` einen Iterator, ruft wiederholt `next()` auf und fängt `StopIteration` ab, um sauber zu enden.

Kernantwort: Jede `for`-Schleife in Python ist intern nichts anderes als `iter()` + wiederholtes `next()` + Abfangen von `StopIteration`.

Diese "manuelle for-Schleife" zeigt, was Python für dich versteckt:

meine_liste = ["a", "b", "c"]

# Das hier ...
for element in meine_liste:
    print(element)

# ... macht intern das hier:
iterator = iter(meine_liste)
while True:
    try:
        element = next(iterator)
        print(element)
    except StopIteration:
        break

Warum ist das wichtig für dich? Weil du in Prüfungen oder Vorstellungsgesprächen oft gefragt wirst, wie Iteration in Python wirklich funktioniert. Wer nur "die Schleife geht durch die Liste" sagen kann, wirkt schnell wie ein Anfänger. Wer den `iter()`/`next()`-Mechanismus erklärt, zeigt echtes Verständnis.

Wie schreibst du eigene Iterables mit __iter__ und __next__?

Wenn du eine eigene Klasse mit Iterations-Fähigkeit ausstattest, hast du zwei Möglichkeiten: Du machst die Klasse selbst zum Iterator (beide Methoden in einer Klasse) oder du trennst Iterable und Iterator sauber. Die saubere Variante zeigt dir das Muster am deutlichsten.

class Zaehler:
    """Iterable: liefert bei jedem Durchlauf einen neuen Iterator."""

    def __init__(self, start, ende):
        self.start = start
        self.ende = ende

    def __iter__(self):
        return ZaehlerIterator(self.start, self.ende)


class ZaehlerIterator:
    """Iterator: merkt sich den aktuellen Zustand."""

    def __init__(self, start, ende):
        self.aktuell = start
        self.ende = ende

    def __iter__(self):
        return self  # ein Iterator gibt sich selbst zurueck

    def __next__(self):
        if self.aktuell >= self.ende:
            raise StopIteration  # Signal: Iteration beendet
        wert = self.aktuell
        self.aktuell += 1
        return wert


for zahl in Zaehler(1, 4):
    print(zahl)  # 1, 2, 3

Warum die Trennung in zwei Klassen? Weil sich ein Iterator seinen Zustand merkt (`self.aktuell`) und nach dem Durchlauf erschöpft ist. Bei der Trennung bekommst du mit jedem `for`-Durchlauf einen frischen Iterator und kannst mehrfach über dasselbe Objekt iterieren. Genauso machen es Listen auch.

Wenn die Klasse nur einmal durchlaufen werden soll, kannst du `__iter__` und `__next__` auch in eine einzige Klasse packen - einfacher, aber eben nur einmal verwendbar.

Übrigens: Methoden mit doppelten Unterstrichen wie `__iter__` und `__next__` heißen Dunder-Methoden. Mehr dazu im Artikel zu Python Dunder Methoden.

Welche typischen Fehler passieren bei Iterable und Iterator?

Fehler 1: next() direkt auf ein Iterable aufrufen

meine_liste = [1, 2, 3]

# Falsch: Listen sind Iterables, aber keine Iteratoren
next(meine_liste)  # TypeError: 'list' object is not an iterator

# Richtig: erst iter(), dann next()
iterator = iter(meine_liste)
print(next(iterator))  # 1

Die Fehlermeldung `TypeError: 'list' object is not an iterator` sehen fast alle Anfänger mindestens einmal. Sie ist harmlos - du hast nur `iter()` vergessen.

Fehler 2: Erschöpften Iterator wiederverwenden

Ein Iterator ist nach dem Durchlauf leer. Eine zweite `for`-Schleife über denselben Iterator läuft dann einfach gar nicht durch:

zahlen = iter([1, 2, 3])

for z in zahlen:
    print(z)  # 1, 2, 3

for z in zahlen:
    print(z)  # nichts! Iterator ist leer

Das gilt übrigens nicht für Iterables wie Listen - die liefern bei jedem `iter()`-Aufruf einen frischen Iterator. Genau deshalb trennt man die beiden Konzepte.

Fehler 3: StopIteration in eigenen Funktionen werfen

Wenn eine deiner Funktionen versehentlich `StopIteration` wirft (zum Beispiel durch ein `next()` ohne Default-Wert), kann das in Generatoren zu verwirrendem Verhalten führen. Ab Python 3.7 (PEP 479) wird eine `StopIteration` im Generator-Kontext automatisch in `RuntimeError` umgewandelt. Nutze deshalb lieber `next(iterator, default)` mit Fallback-Wert, statt die Ausnahme selbst zu fangen.

Übung: Erweitere die Zaehler-Klasse

Nimm die `Zaehler`-Klasse von oben und erweitere sie: Der Iterator soll nur gerade Zahlen zwischen 1 und 20 liefern. Danach füge eine Klasse `EndlosZaehler` hinzu, die nie `StopIteration` wirft - und brich die Schleife stattdessen mit `break` nach 5 Durchläufen ab.

Warum diese Übung? Weil du dabei beide Richtungen erlebst: Iteration mit definiertem Ende und Iteration ohne Ende (so funktionieren z. B. `itertools.count()` oder unendliche Generatoren). Wenn du danach eine `for`-Schleife siehst, weißt du sofort, was unter der Haube passiert.

FAQ: Häufige Fragen zu Iterable und Iterator

Was ist der Unterschied zwischen Iterable und Iterator?

Ein Iterable implementiert `__iter__()` und kann einen Iterator liefern. Ein Iterator implementiert zusätzlich `__next__()` und liefert Elemente nacheinander. Eine Liste ist ein Iterable, das Objekt von `iter(meine_liste)` ist der Iterator.

Ist ein Iterator auch ein Iterable?

Ja. Ein Iterator gibt bei `__iter__()` sich selbst zurück und kann deshalb direkt in `for`-Schleifen verwendet werden. Umgekehrt ist ein Iterable ohne `__next__` kein Iterator.

Was macht StopIteration?

`StopIteration` ist die Ausnahme, die `__next__()` wirft, wenn keine Elemente mehr übrig sind. Die `for`-Schleife fängt sie intern ab und beendet sich dadurch sauber.

Warum kann ich über einen Iterator nur einmal iterieren?

Weil ein Iterator seinen Zustand speichert und nach dem letzten Element erschöpft ist. Ein erneuter Aufruf von `iter()` auf demselben Iterator gibt denselben (leeren) Iterator zurück - es entstehen keine neuen Elemente.

Was haben Generatoren mit Iteratoren zu tun?

Generatoren (Funktionen mit `yield`) sind eine Abkürzung, um automatisch Iteratoren zu erzeugen. Python schreibt dir dabei `__iter__` und `__next__` inklusive `StopIteration` selbst. Details dazu findest du in der offiziellen Python-Dokumentation.

Fazit

Iterable und Iterator sind das Fundament hinter jeder `for`-Schleife in Python: Das Iterable hält die Daten, der Iterator blättert sich durch. Mit `__iter__()` und `__next__()` plus `StopIteration` hast du jetzt das komplette Muster im Kopf - und solche Konzepte tauchen regelmäßig in IHK-Prüfungen, Uni-Klausuren und Einstellungstests auf. Wenn du tiefer in Pythons Objektmodell einsteigen willst, lies dir als Nächstes unseren Artikel zu Python Dunder Methoden durch, oder kläre mit self in Python die Basics von Klassen.

Und wenn du beim Lernen feststeckst - egal ob Azubi, Student oder Berufseinsteiger - hol dir individuelle Unterstützung bei study-it.education. Wir erklären dir Python-Konzepte so lange, bis sie sitzen.