Stellen Sie sich vor, Sie laden eine 10-GB-Protokolldatei in eine Liste, nur um die Fehler zu finden. Möglicherweise geht Ihrem Programm der Speicher aus, bevor es einen findet. Python-Generatoren lösen dieses Problem, indem sie Werte nach Bedarf einzeln erzeugen, sodass Sie riesige oder sogar endlose Daten fast ohne Speicher verarbeiten können.

Diese Anleitung zeigt Schritt für Schritt, was wirklich passiert, wenn ein Generator läuft. Wir haben jedes Beispiel auf Python 3.13 ausgeführt und die Ausgabe stammt von diesem Lauf. Es ist hilfreich, bereits mit Funktionen und Schleifen vertraut zu sein, die in unserem Python-Tutorial für Anfänger behandelt werden.

Was ist ein Generator?

Ein Generator ist eine besondere Art von Iterator, den Sie erstellen, indem Sie mit yield eine Funktion schreiben. Jede Funktion mit yield wird automatisch zu einer Generatorfunktion, und wenn Sie sie aufrufen, erhalten Sie ein Generatorobjekt, anstatt den Code auszuführen.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Beachten Sie, dass „starting“ nicht gedruckt wurde. Durch den Aufruf der Funktion wurde nur der Generator erstellt. Drinnen ist noch nichts gelaufen.

Wie Yield funktioniert, Schritt für Schritt

Jeder Aufruf von next() führt die Funktion aus, bis sie eine yield erreicht, gibt diesen Wert zurück und friert an Ort und Stelle ein. Der nächste Aufruf wird direkt nach dieser Zeile fortgesetzt, wobei alle lokalen Variablen intakt bleiben.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Befolgen Sie die Ausgabe sorgfältig. „starting“ erscheint nur auf der ersten next(). Beim zweiten Schritt wird die Ausführung an der Stelle fortgesetzt, an der sie gestoppt wurde, sodass n immer noch verfügbar ist und zu 2 wird. Beim dritten Ende endet die Schleife, „fertig“ wird gedruckt, die Funktion fällt aus dem Ende und Python erhöht StopIteration, um zu signalisieren, dass nichts mehr übrig ist.

Du rufst dich selten next() an. Eine for-Schleife erledigt das für Sie und verarbeitet StopIteration leise, ebenso wie list(), sum() und ähnliche Funktionen:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

Rendite vs. Rendite

Diese Verzögerung wird als verzögerte Auswertung bezeichnet: Werte werden nur dann berechnet, wenn sie benötigt werden. Eine einfache return in einem Generator beendet ihn einfach, was StopIteration auslöst.

Der Gedächtnisunterschied, gemessen

Wir haben eine Liste von einer Million Quadraten mit einem äquivalenten Generator verglichen und dabei sys.getsizeof verwendet:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

Die eigene Struktur der Liste benötigte etwa 8,4 MB, während der Generator auf unserem System nur 200 Bytes benötigte. Die tatsächliche Lücke ist sogar noch größer, da getsizeof die ganzzahligen Objekte in der Liste nicht zählt. Auch die Größe des Generators bleibt für eine Milliarde Elemente gleich, da er nur seinen aktuellen Zustand und nicht seine Ergebnisse speichert.

Es gibt jedoch einen Kompromiss. Eine Liste kann mit len() wiederverwendet, indiziert und gemessen werden. Ein Generator bietet nichts davon. Wenn Sie wahlfreien Zugriff benötigen oder eine kleine Datenmenge mehrmals durchlaufen, ist eine Liste einfacher. Weitere Informationen zu diesen Typen finden Sie in unserem Leitfaden zu Python-Liste vs. Tupel vs. Set.

Generatorausdrücke

Für einfache Fälle benötigen Sie keine Funktion. Ein Generatorausdruck sieht aus wie ein Listenverständnis mit runden Klammern anstelle von eckigen:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Wenn ein Generatorausdruck das einzige Argument einer Funktion ist, wie in sum(), können Sie die zusätzlichen Klammern weglassen. Dies ist eine gute Angewohnheit für Summen über große Datenmengen, da keine temporäre Liste erstellt wird.

Erstellen Sie eine Datenpipeline

Hier glänzen Generatoren wirklich. Kleine Generatoren können verkettet werden, sodass jedes Element nacheinander jeden Schritt durchläuft:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Jeder Schritt erledigt eine kleine Aufgabe und kann einzeln getestet werden. Tauschen Sie im realen Einsatz die Beispielliste gegen eine geöffnete Datei aus, da Dateiobjekte Zeile für Zeile gelesen werden können, wie unser Leitfaden zum Python-Dateihandling zeigt. Sogar ein Multi-Gigabyte-Protokoll würde dann mit sehr wenig Speicher passieren.

Unendliche Folgen

Eine Liste kann nicht unendlich sein, ein Generator jedoch schon, da er immer nur den nächsten Wert berechnet. Verwenden Sie itertools.islice, um so viele zu nehmen, wie Sie benötigen:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Seien Sie jedoch vorsichtig: Der Aufruf von list(fibonacci()) ohne Limit würde so lange laufen, bis Ihr Speicher aufgebraucht ist. Das gleiche Muster eignet sich für ID-Generatoren, Abfrageschleifen und paginierte API-Ergebnisse, bei denen Sie die nächste Seite erst abrufen, wenn die aktuelle Seite abgelaufen ist.

Ausbeute und Chargen

yield from Überlassen Sie es einer anderen Iterable und ersparen Sie sich so eine verschachtelte Schleife:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Ein sehr praktisches Muster ist das Aufteilen von Daten in Stapel fester Größe, um beispielsweise tausend Zeilen gleichzeitig in eine Datenbank einzufügen:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

Das Finale if batch stellt sicher, dass eine kleinere übrig gebliebene Gruppe nicht verloren geht. Python 3.12 und höher enthalten auch itertools.batched, das eine ähnliche Aufgabe erfüllt.

Senden, schließen und bereinigen

Auch Generatoren können Werte empfangen. send() setzt den Generator fort und der Wert wird zum Ergebnis des yield-Ausdrucks. Sie müssen next() zuerst einmal anrufen, um den ersten yield zu erreichen:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

Die meisten Menschen brauchen dies selten. Ein häufigeres Problem ist die Bereinigung. Wenn Sie vorzeitig stoppen, läuft ein finally-Block immer noch, wenn der Generator geschlossen ist:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest nutzt genau diese Idee: Ein Fixture mit yield führt anschließend seine Bereinigung durch, wie unser Pytest-Tutorial zeigt. Ebenso verwandelt der contextmanager-Dekorator der Standardbibliothek einen Generator in einen with-Block.

Generatoren in Klassen

Das Schreiben einer __iter__-Methode als Generator ist der einfachste Weg, Ihre eigene Klasse iterierbar zu machen. Ein Bonus ist, dass jede Schleife einen neuen Generator erhält, sodass das Objekt immer wieder wiederholt werden kann:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Wann sollte ein Generator verwendet werden?

Ein Generator ist insgesamt nicht immer schneller. Wenn Sie am Ende jeden Wert verwenden, ist die Gesamtarbeit ähnlich, und das Listenverständnis kann bei kleinen Datenmengen sogar schneller erfolgen, da weniger Overhead pro Element entsteht. Die Hauptvorteile liegen in der Speichernutzung und der schnelleren Erzielung erster Ergebnisse.

Häufige Fehler

Wiederverwendung eines erschöpften Generators

Das erwischt irgendwann fast jeden. Ein Generator merkt sich, dass er fertig ist:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

Der zweite Aufruf erhält eine leere Liste ohne Fehler. Rufen Sie die Funktion erneut auf, um einen neuen Generator zu erhalten, oder verwenden Sie den oben gezeigten Klassenansatz.

Es wird erwartet, dass der Code sofort ausgeführt wird

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Argumentprüfungen am Anfang eines Generators werden erst beim ersten next() ausgeführt, sodass Fehler weit entfernt von dem Aufruf auftreten können, der sie verursacht hat.

Andere Fallen

• Aufrufen von len() oder Indizieren. Generatoren unterstützen keines von beiden und lösen eine TypeError aus.
• Eine Datei zu früh schließen. Das Zurückgeben eines Generators aus einem with-Block kann bedeuten, dass die Datei geschlossen wird, bevor eine Zeile gelesen wird. Setzen Sie die yield in den with-Block.
• Alles in list() einpacken. Das macht den Speichervorteil zunichte.
• Verwenden Sie eines für kleine Daten. Eine einfache Liste ist oft klarer.

Fazit

Ein Generator ist eine Funktion, die pausieren kann. Diese eine Idee sorgt für eine geringe Speichernutzung, endlose Sequenzen und saubere Pipelines. Um es in die Praxis umzusetzen, suchen Sie in Ihrem Code eine Stelle, die eine große Liste erstellt, nur um sie einmal zu durchlaufen, und wandeln Sie diese in einen Generator um. Versuchen Sie dann, zwei kleine Generatoren in einer echten Protokolldatei miteinander zu verketten.

Häufige Fragen

Lerne weiter