Flugtickets

Ein generator ist eine Funktion oder ein Ausdruck, der einen speziellen Typ von Iterator zurückgibt, den sogenannten generator iterator. Generator-iterators sind lazy: Sie speichern ihre values nicht im Speicher, sondern erzeugen ihre Werte erst, wenn sie gebraucht werden.

Eine Generatorfunktion sieht aus wie jede andere Funktion, enthält aber einen oder mehrere yield-Ausdrücke. Jedes yield unterbricht die Ausführung des Codes und speichert den aktuellen Ausführungszustand (einschließlich aller lokalen Variablen und try-Anweisungen). Wenn der Generator fortgesetzt wird, nimmt er den Zustand von der Unterbrechung wieder auf, anders als reguläre Funktionen, die mit jedem Aufruf zurückgesetzt werden.

Einen Generator erstellen

Generatoren werden ähnlich konstruiert wie andere Schleifen- oder rekursive Funktionen, benötigen aber einen yield-Ausdruck, den wir uns später noch genauer ansehen.

Ein Beispiel ist eine Funktion, die die Quadrate aus einer gegebenen Liste von Zahlen zurückgibt. So wie sie derzeit geschrieben ist, muss die gesamte Eingabe verarbeitet werden, bevor Werte zurückgegeben werden können:

>>> def squares(list_of_numbers):
...     squares = []
...     for number in list_of_numbers:
...         squares.append(number ** 2)
...     return squares

Du kannst diese Funktion so in einen Generator umwandeln:

>>> def squares_generator(list_of_numbers):
...     for number in list_of_numbers:
...         yield number ** 2

Der Grundgedanke dahinter ist, dass du einen Generator verwendest, wenn du nicht alle Werte auf einmal erzeugen musst. Das spart Speicher und Rechenleistung, da nur der Wert berechnet wird, an dem du gerade arbeitest.

Einen Generator verwenden

Generatoren können in Python die meisten iterables ersetzen. Das schließt Funktionen oder Objekte ein, die ein iterable/iterator als Argument erwarten.

So verwendest du den Generator squares_generator():

>>> squared_numbers = squares_generator([1, 2, 3, 4])

>>> for square in squared_numbers:
...     print(square)
...
1
4
9
16

Werte innerhalb eines generator können auch über die Funktion next() erzeugt oder abgerufen werden. next() ruft die Methode __next__() eines Generator-Iterator-Objekts auf, „bringt“ den Code also voran und wertet ihn bis zu seinem yield-Ausdruck aus, der dann einen Wert „liefert“ oder zurückgibt:

>>> squared_numbers = squares_generator([1, 2])

>>> next(squared_numbers)
1
>>> next(squared_numbers)
4

Wenn ein generator-iterator vollständig verbraucht ist und keine Werte mehr zurückzugeben hat, wirft er einen StopIteration-Fehler.

>>> next(squared_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Der yield-Ausdruck

Der yield-Ausdruck ist dem return-Ausdruck sehr ähnlich. Anders als beim return-Ausdruck gibt yield Werte an den Aufrufer an einem bestimmten Punkt ab und unterbricht die Auswertung/Rückgabe weiterer Werte, bis diese angefordert werden. Wenn yield ausgewertet wird, pausiert es die Ausführung der umgebenden Funktion und gibt alle Werte der Funktion zu diesem Zeitpunkt zurück. Die Funktion bleibt dann im Gültigkeitsbereich, und wenn __next__() aufgerufen wird, wird die Ausführung fortgesetzt, bis yield erneut angetroffen wird.

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

>>> lets_try = infinite_sequence()
>>> lets_try.__next__()
0
>>> lets_try.__next__()
1

Warum einen Generator erstellen?

Generatoren sind in vielen Anwendungen nützlich.

Wenn du mit einer potenziell großen Sammlung von Werten arbeitest, möchtest du vielleicht nicht alle davon in den Speicher laden. Ein Generator kann verwendet werden, um größere Daten Stück für Stück zu verarbeiten, was Speicher spart und die Leistung verbessert.

Generatoren sind auch sehr hilfreich, wenn ein Prozess oder eine Berechnung komplex, teuer oder unendlich ist:

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

Wenn nun __next__() für das Objekt infinite_sequence aufgerufen wird, gibt es die vorherige Zahl + 1 zurück.