Python Generatoren: Effiziente Iteration und fortgeschrittene Anwendungsfälle

Python Generatoren

Entdecken Sie, wie Python-Generatoren Iteration vereinfachen, Boilerplate reduzieren und den Speicherverbrauch im Vergleich zu traditionellen Iteratoren verbessern.

Was sind Generatoren?

Das Erstellen eines benutzerdefinierten Iterators in Python erfordert normalerweise eine Klasse, die __iter__() und __next__() implementiert, internen Zustand verwaltet und StopIteration auslöst, wenn fertig. Generatoren eliminieren diesen Boilerplate, indem sie es Ihnen erlauben, eine einfache Funktion zu schreiben, die Werte nacheinander yield.

Kurz gesagt: Ein Generator ist eine Funktion, die einen Iterator zurückgibt. Der Funktionskörper wird faul ausgeführt, pausiert nach jedem yield und setzt bei nachfolgenden Aufrufen fort.

Generatoren in Python erstellen

Einen Generator zu definieren ist so einfach wie eine normale Funktion zu schreiben und return durch yield zu ersetzen:

def mein_gen():
    n = 1
    print('Dies wird zuerst ausgegeben')
    yield n
    n += 1
    print('Dies wird zweitens ausgegeben')
    yield n
    n += 1
    print('Dies wird zuletzt ausgegeben')
    yield n

Der Aufruf von mein_gen() gibt einen Iterator zurück, der erst ausführt, wenn next() aufgerufen wird.

a = mein_gen()
next(a)  # gibt erste Nachricht aus und liefert 1
next(a)  # gibt zweite Nachricht aus und liefert 2
next(a)  # gibt letzte Nachricht aus und liefert 3
next(a)  # löst StopIteration aus

Lokale Variablen bleiben zwischen yields erhalten, aber der Generator kann nur einmal iteriert werden. Für einen Neustart erstellen Sie eine neue Instanz.

Da ein Generator ein Iterator ist, können Sie direkt darüber loopen:

for item in mein_gen():
    print(item)

Gängige Generator-Muster

String umkehren

def rev_str(s):
    for i in range(len(s)-1, -1, -1):
        yield s[i]
for char in rev_str('hallo'):
    print(char)

Funktioniert mit jedem Iterierbaren (Liste, Tupel, etc.).

Generator Expressions

Anonyme Generatoren können mit Klammern erstellt werden, ähnlich wie List Comprehensions:

meine_liste = [1, 3, 6, 10]
# List Comprehension
quadrate_liste = [x**2 for x in meine_liste]
# Generator Expression
quadrate_gen = (x**2 for x in meine_liste)
print(quadrate_liste)
print(quadrate_gen)

a = (x**2 for x in meine_liste)
print(next(a))  # 1
print(next(a))  # 9
print(next(a))  # 36
print(next(a))  # 100
next(a)  # StopIteration

Generator Expressions können direkt an Funktionen wie sum oder max übergeben werden, ohne die umgebenden Klammern.

Warum Generatoren verwenden?

Kurze Implementierung: Ersetzt verbose Iterator-Klassen durch wenige Codezeilen.
Speichereffizienz: Produziert ein Element nach dem anderen, ideal für große oder unendliche Sequenzen.
Unendliche Streams: Repräsentiert endlose Datenquellen (z. B. while True: yield).
Pipeline-Komposition: Verkettet mehrere Generatoren für saubere, lesbare Datenverarbeitung.

Beispiel: Zweierpotenzen

def pow_two_gen(max_n=0):
    n = 0
    while n < max_n:
        yield 2 ** n
        n += 1

Beispiel: Summe der Quadrate von Fibonacci-Zahlen

def fibonacci_zahlen(anzahl):
    a, b = 0, 1
    for _ in range(anzahl):
        a, b = b, a + b
        yield a
def quadriere(zahlen):
    for n in zahlen:
        yield n ** 2
print(sum(quadriere(fibonacci_zahlen(10))))  # 4895

Generatoren ermöglichen eleganten, effizienten und wartbaren Code für eine breite Palette von Iterationsszenarien.

Python Iteratoren meistern: Funktionsweise und Erstellung eigener Iteratoren Python Closures erklärt: Wie verschachtelte Funktionen Variablen erfassen

Python