9. Klassen — Das Python3.3-Tutorial auf Deutsch (2024)

9.1. Ein Wort zu Namen und Objekten¶

Objekte haben Individualität und mehrere Namen (in mehrerenGültigkeitsbereichen) können an dasselbe Objekt gebunden werden. In anderenSprachen wird dies als Aliasing bezeichnet. Das wird meist beim ersten Blickauf Python nicht geschätzt und kann problemlos ignoriert werden, wenn man mitunveränderbaren Datentypen (Zahlen, Zeichenketten, Tupel) arbeitet. AberAliasing hat einen möglicherweise überraschenden Effekt auf die Semantik vonPythoncode, der veränderbare Objekte wie Listen, Dictionaries oder die meistenanderen Typen, enthält. Dies kommt normalerweise dem Programm zugute, da sichAliase in mancher Hinsicht wie Pointer verhalten. Zum Beispiel ist die Übergabeeines Objekts günstig, da von der Implementierung nur ein Pointer übergebenwird. Verändert eine Funktion ein Objekt, das als Argument übergeben wurde, wirdder Aufrufende die Veränderung sehen — dies vermeidet den Bedarf an zweiverschiedenen Übergabemechanismen, wie in Pascal.

9.2. Gültigkeitsbereiche und Namensräume in Python¶

Bevor man Klassen überhaupt einführt, muss man über Pythons Regeln im Bezug aufGültigkeitsbereiche reden. Klassendefinitionen wenden ein paar nette Kniffe beiNamensräumen an und man muss wissen wie Gültigkeitsbereiche und Namensräumefunktionieren, um vollkommen zu verstehen was abläuft. Außerdem ist das Wissenhierüber nützlich für jeden fortgeschrittenen Pythonprogrammierer.

Fangen wir mit ein paar Definitionen an.

Ein Namensraum ist eine Zuordnung von Namen zu Objekten. Die meistenNamensräume sind momentan als Dictionaries implementiert, aber das istnormalerweise in keinerlei Hinsicht spürbar (außer bei der Performance) und kannsich in Zukunft ändern. Beispiele für Namensräume sind: Die Menge dereingebauten Namen (die Funktionen wie abs() und eingebaute Ausnahmenenthält), die globalen Namen eines Moduls und die lokalen Namen einesFunktionsaufrufs. In gewisser Hinsicht bilden auch die Attribute eines Objekteseinen Namensraum. Das Wichtigste, das man über Namensräume wissen muss, ist,dass es absolut keinen Bezug von Namen in verschiedenen Namensräumen zueinandergibt. Zum Beispiel können zwei verschiedene Module eine Funktion namensmaximize definieren, ohne dass es zu einer Verwechslung kommt, denn Benutzerdes Moduls müssen dessen Namen voranstellen.

Nebenbei bemerkt: Ich benutze das Wort Attribut für jeden Namen nach einemPunkt — zum Beispiel in dem Ausdruck z.real ist real ein Attribut desObjekts z. Genau genommen sind auch Referenzen zu Namen in ModulenAttributreferenzen: Im Ausdruck modname.funcname, ist modname einModulobjekt und funcname ein Attribut dessen. In diesem Fall gibt es einegeradlinige Zuordnung von Modulattributen und globalen Namen, die im Moduldefiniert sind: Sie teilen sich denselben Namensraum! [1]

Attribute können schreibgeschützt oder veränderbar sein. In letzterem Fall isteine Zuweisung an dieses Attribut möglich. Modulattribute sind veränderbar: Mankann modname.the_answer = 42 schreiben. Veränderbare Attribute sindgleichzeitig durch die del-Anweisung löschbar. Zum Beispiel löschtdel modname.the_answer das Attribut the_answer des Objekts namensmodname.

Namensräume werden zu verschiedenen Zeitpunkten erzeugt und haben verschiedeneLebenszeiten. Der Namensraum, der die eingebauten Namen enthält, wird beim Startdes Interpreters erzeugt und nie gelöscht. Der globale Namensraum für ein Modulwird erzeugt, wenn die Moduldefinition eingelesen wird; normalerweise existierendie Namensräume des Moduls auch solange bis der Interpreter beendet wird. DieAnweisungen, die auf oberster Ebene vom Interpreter aufgerufen werden, entwedervon einem Skript oder interaktiv gelesen, werden als Teil des Moduls__main__ behandelt, sodass sie ihren eigenen globalen Namensraum haben.(Die eingebauten Namen existieren ebenfalls in einem Modul namensbuiltins.)

Der lokale Namensraum einer Funktion wird bei deren Aufruf erstellt und wirdgelöscht, wenn sich die Funktion beendet oder eine Ausnahme auslöst, die nichtinnerhalb der Funktion behandelt wird. (Eigentlich wäre “vergessen” eine bessereBeschreibung dessen, was passiert.) Natürlich haben auch rekursive Aufrufe ihrenjeweiligen lokalen Namensraum.

Ein Gültigkeitsbereich (scope) ist eine Region eines Python-Programms, inder ein Namensraum direkt verfügbar ist, das heisst es einem unqualifiziertemNamen möglich ist einen Namen in diesem Namensraum zu finden.

Auch wenn Gültigkeitsbereiche statisch ermittelt werden, werden sie dynamischbenutzt. An einem beliebigen Zeitpunkt während der Ausführung, gibt esmindestens drei verschachtelte Gültigkeitsbereiche, deren Namensräume direktverfügbar sind:

• Der innerste Gültigkeitsbereich, der zuerst durchsucht wird und die lokalenNamen enthält;
• der Gültigkeitsbereich mit allen umgebenden Namensräumen (enthält auch dieglobalen Namen des momentanen Moduls), der vom nächsten umgebenden Namensraumaus durchsucht wird, und nicht-lokale, aber auch nicht-globale Namen enthält;
• der vorletzte Gültigkeitsbereich enthält die globalen Namen des aktuellenModuls;
• der letzte Gültigkeitsbereich (zuletzt durchsuchte) ist der Namensraum, derdie eingebauten Namen enthält.

Wird ein Name als global deklariert, so gehen alle Referenzen undZuweisungen direkt an den mittleren Gültigkeitsbereich, der die globalen Namendes Moduls enthält. Um Variablen, die außerhalb des innerstenGültigkeitsbereichs zu finden sind, neu zu binden, kann dienonlocal-Anweisung benutzt werden. Falls diese nicht alsnonlocal deklariert sind, sind diese Variablen schreibgeschützt (ein Versuchin diese Variablen zu schreiben, würde einfach eine neue lokale Variable iminnersten Gültigkeitsbereich anlegen und die äußere Variable mit demselben Namenunverändert lassen).

Normalerweise referenziert der lokale Gültigkeitsbereich die lokalen Namen dermomentanen Funktion. Außerhalb von Funktionen bezieht sich der lokaleGültigkeitsbereich auf denselben Namensraum wie der globale Gültigkeitsbereich:Den Namensraum des Moduls. Klassendefinitionen stellen einen weiterenNamensraum im lokalen Gültigkeitsbereich dar.

Es ist wichtig zu verstehen, dass die Gültigkeitsbereiche am Text ermitteltwerden: Der globale Gültigkeitsbereich einer Funktion, die in einem Moduldefiniert wird, ist der Namensraum des Moduls, ganz egal wo die Funktionaufgerufen wird. Andererseits wird die tatsächliche Suche nach Namen dynamischzur Laufzeit durchgeführt — jedoch entwickelt sich die Definition der Sprachehin zu einer statischen Namensauflösung zur Kompilierzeit, deshalb sollte mansich nicht auf die dynamische Namensauflösung verlassen! (In der Tat werdenlokale Variablen schon statisch ermittelt.)

Eine besondere Eigenart Pythons ist, dass – wenn keineglobal-Anweisung aktiv ist – Zuweisungen an Namen immer im innerstenGültigkeitsbereich abgewickelt werden. Zuweisungen kopieren keineDaten, sondern binden nur Namen an Objekte. Das gleiche gilt für Löschungen: DieAnweisung del x entfernt nur die Bindung von x aus dem Namensraum deslokalen Gültigkeitsbereichs. In der Tat benutzen alle Operationen, die neueNamen einführen, den lokalen Gültigkeitsbereich: Im Besonderen bindenimport-Anweisungen und Funktionsdefinitionen das Modulbeziehungsweise den Funktionsnamen im lokalen Gültigkeitsbereich.

Die global-Anweisung kann benutzt werden, um anzuzeigen, dassbestimmte Variablen im globalen Gültigkeitsbereich existieren und hierneu gebunden werden sollen. Die nonlocal-Anweisung zeigt an, dasseine bestimmte Variable im umgebenden Gültigkeitsbereich existiert und hierneu gebunden werden soll.

def scope_test(): def do_local(): spam = "local spam" def do_nonlocal(): nonlocal spam spam = "nonlocal spam" def do_global(): global spam spam = "global spam" spam = "test spam" do_local() print("Nach der lokalen Zuweisung:", spam) do_nonlocal() print("Nach der nonlocal Zuweisung:", spam) do_global() print("Nach der global Zuweisung:", spam)scope_test()print("Im globalen Gültigkeitsbereich:", spam)

.. code-block:: none Nach der lokalen Zuweisung: test spam Nach der nonlocal Zuweisung: nonlocal spam Nach der global Zuweisung: nonlocal spam Im globalen Gültigkeitsbereich: global spam

9.3. Eine erste Betrachtung von Klassen¶

Klassen führen ein kleines bisschen neue Syntax, drei neue Objekttypen und einwenig neue Semantik ein.

class ClassName: <anweisung-1> . . . <anweisung-N>

class MyClass: """A simple example class""" i = 12345 def f(self): return 'Hallo Welt'

x = MyClass()

def __init__(self): self.data = []

x = MyClass()

>>> class Complex:...  def __init__(self, realpart, imagpart):...  self.r = realpart...  self.i = imagpart...>>> x = Complex(3.0, -4.5)>>> x.r, x.i(3.0, -4.5)

x.counter = 1while x.counter < 10: x.counter = x.counter * 2print(x.counter)del x.counter

x.f()

xf = x.fwhile True: print(xf())

9.4. Beiläufige Anmerkungen¶

Datenattribute überschreiben Methodenattribute desselben Namens. Um zufälligeNamenskonflikte zu vermeiden, die zu schwer auffindbaren Fehlern in großenProgrammen führen, ist es sinnvoll sich auf irgendeine Konvention zuverständigen, die das Risiko solcher Konflikte vermindern. Mögliche Konventionenbeinhalten das Großschreiben von Methodennamen, das Voranstellen von kleineneindeutigen Zeichenketten (vielleicht auch nur ein Unterstrich) beiDatenattributen oder das Benutzen von Verben bei Methodennamen und Nomen beiDatenattributen.

Datenattribute können von Methoden, genauso wie von normalen Benutzern(“clients”) eines Objektes referenziert werden. In anderen Worten: Klassen sindnicht benutzbar, um reine abstrakte Datentypen (“abstract data types”) zuimplementieren. In Wirklichkeit, gibt es in Python keine Möglichkeit umDatenkapselung (data hiding) zu erzwingen — alles basiert auf Konventionen.(Auf der anderen Seite kann die Python-Implementierung, in C geschrieben,Implementationsdetails komplett verstecken und den Zugriff auf ein Objektkontrollieren, wenn das nötig ist; das kann von in C geschriebenenPython-Erweiterungen ebenfalls benutzt werden.)

Clients sollten Datenattribute mit Bedacht nutzen, denn sie könnten Invariantenkaputt machen, die von Methoden verwaltet werden, indem sie auf derenDatenattributen herumtrampeln. Man sollte beachten, dass Clients zu ihremeigenen Instanzobjekt Datenattribute hinzufügen können, ohne die Gültigkeit derMethoden zu gefährden, sofern Namenskonflikte vermieden werden — auch hierkann eine Bennenungskonvention viele Kopfschmerzen ersparen.

Es gibt keine Abkürzung, um Datenattribute (oder andere Methoden!) innerhalb vonMethoden zu referenzieren. Meiner Meinung verhilft das Methoden zu bessererLesbarkeit: Man läuft keine Gefahr, lokale und Instanzvariablen zu verwechseln,wenn man eine Methode überfliegt.

Oft wird das erste Argument einer Methode self genannt. Dies ist nichtsanderes als eine Konvention: Der Name self hat absolut keine spezielleBedeutung für Python. Aber beachte: Hälst du dich nicht an die Konvention, kanndein Code schwerer lesbar für andere Python-Programmierer sein und es ist auchvorstellbar, dass ein Klassenbrowser (class browser) sich auf dieseKonvention verlässt.

Jedes Funktionsobjekt, das ein Klassenattribut ist, definiert eine Methode fürInstanzen dieser Klasse. Es ist nicht nötig, dass die Funktionsdefinition imText innerhalb der Klassendefinition ist: Die Zuweisung eines Funktionsobjektesan eine lokale Variable innerhalb der Klasse ist ebenfalls in Ordnung. ZumBeispiel:

# Funktionsdefintion außerhalb der Klassedef f1(self, x, y): return min(x, x+y)class C: f = f1 def g(self): return 'Hallo Welt' h = g

f, g und h sind jetzt alle Attribute der Klasse C, dieFunktionsobjekte referenzieren und somit sind sie auch alle Methoden derInstanzen von C — h ist dabei gleichbedeutend mit g. Beachteaber, dass diese Praxis nur dazu dient einen Leser des Programms zu verwirren.

Methoden können auch andere Methoden aufrufen, indem sie das Methodenattributdes Arguments self benutzen:

class Bag: def __init__(self): self.data = [] def add(self, x): self.data.append(x) def addtwice(self, x): self.add(x) self.add(x)

Methoden können globale Namen genauso wie normale Funktionen referenzieren. Derglobale Gültigkeitsbereich der Methode ist das Modul, das die Klassendefinitionenthält. (Eine Klasse selbst wird nie als globaler Gültigkeitsbereich benutzt.)Während man selten einen guten Grund dafür hat globale Daten zu benutzen, gibtes viele berechtigte Verwendungen des globalen Gültigkeitsbereichs: Zum einenkönnen Funktionen und Module, die in den globalen Gültigkeitsbereich importiertwerden, genauso wie Funktionen und Klassen die darin definiert werden, von derMethode benutzt werden. Normalerweise ist die Klasse, die die Methode enthält,selbst in diesem globalen Gültigkeitsbereich definiert und im nächsten Abschnittwerden wir ein paar gute Gründe entdecken, warum eine Methode die eigene Klassereferenzieren wollte.

Jeder Wert ist ein Objekt und hat deshalb eine Klasse (auch type genannt).Es wird als Objekt.__class__ abgelegt.

9.5. Vererbung¶

Natürlich verdient ein Sprachmerkmal nicht den Namen “Klasse”, wenn es nichtVererbung unterstützt. Die Syntax für eine abgeleitete Klassendefinition siehtso aus:

class DerivedClassName(BaseClassName): <statement-1> . . . <statement-N>

Der Name BaseClassName muss innerhalb des Gültigkeitsbereichs, der dieabgeleitete Klassendefinition enthält, definiert sein. Anstelle einesBasisklassennamens sind auch andere willkürliche Ausdrücke erlaubt. Dies kannbeispielsweise nützlich sein, wenn die Basisklasse in einem anderen Moduldefiniert ist:

class DerivedClassName(modname.BaseClassName):

Die Ausführung einer abgeleiteten Klassendefinition läuft genauso wie bei einerBasisklasse ab. Bei der Erzeugung des Klassenobjekts, wird sich der Basisklasseerinnert. Dies wird zum Auflösen der Attributsreferenzen benutzt: Wird einangefordertes Attribut nicht innerhalb der Klasse gefunden, so wird in derBasisklasse weitergesucht. Diese Regel wird rekursiv angewandt, wenn dieBasisklasse selbst von einer anderen Klasse abgeleitet wird.

Es gibt nichts besonderes an der Instanziierung von abgeleiteten Klassen:DerivedClassName erzeugt eine neue Instanz der Klasse. Methodenreferenzenwerden wie folgt aufgelöst: Das entsprechende Klassenattribut wird durchsucht,falls nötig bis zum Ende der Basisklassenkette hinab und die Methodenreferenzist gültig, wenn es ein Funktionsobjekt bereithält.

Abgeleitete Klassen können Methoden ihrer Basisklassen überschreiben. DaMethoden keine besonderen Privilegien beim Aufrufen anderer Methoden desselbenObjekts haben, kann eine Methode einer Basisklasse, die eine andere Methode, diein derselben Basisklasse definiert wird, aufruft, beim Aufruf einer Methode derabgeleiteten Klasse landen, die sie überschreibt. (Für C++-Programmierer: AlleMethoden in Python sind im Grunde virtual.)

Eine überschreibende Methode in einer abgeleiteten Klasse wird in der Tat eherdie Methode der Basisklasse mit demselben Namen erweitern, statt einfach nur zuersetzen. Es gibt einen einfachen Weg die Basisklassenmethode direkt aufzurufen:Einfach BaseClassName.methodname(self, arguments) aufrufen. Das istgelegentlich auch für Clients nützlich. (Beachte, dass dies nur funktioniert,wenn die Basisklasse als BaseClassName im globalen Gültigkeitsbereichzugänglich ist.)

Python hat zwei eingebaute Funktionen, die mit Vererbung zusammenarbeiten:

• Man benutzt isinstance() um den Typ eines Objekts zu überprüfen:isinstance(obj, int) ist nur dann True, wenn obj.__class__ vom Typint oder einer davon abgeleiteten Klasse ist.
• Man benutzt issubclass() um Klassenvererbung zu überprüfen:issubclass(bool, int) ist True, da bool eine von intabgeleitete Klasse ist. Jedoch ist issubclass(float, int) False, dafloat keine von int abgeleitete Klasse ist.

class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>

9.6. Private Variablen¶

“Private” Instanzvariablen, die nur innerhalb des Objekts zugänglich sind, gibtes in Python nicht. Jedoch gibt es eine Konvention, die im meisten Python-Codebefolgt wird: Ein Name, der mit einem Unterstrich beginnt (z.B. _spam)sollte als nicht-öffentlicher Teil der API behandelt werden (egal ob es eineFunktion, eine Methode oder ein Datenattribut ist). Es sollte alsImplementierungsdetails behandelt werden, das sich unangekündigt ändern kann.

Da es eine sinnvolle Verwendung für klassen-private Attribute gibt, umNamenskonflikte mit Namen, die von Unterklassen definiert werden zu vermeiden,gibt es eine begrenzte Unterstützung für so einen Mechanismus: namemangling (Namensersetzung). Jeder Bezeichner der Form __spam (mindestenszwei führende Unterstriche, höchstens ein folgender) wird im Text durch_classname__spam ersetzt, wobei classname der Name der aktuellen Klasse(ohne eventuelle führende Unterstriche) ist. Die Ersetzung geschieht ohneRücksicht auf die syntaktische Position des Bezeichners, sofern er innerhalb derDefinition der Klasse steht.

Namensersetzung ist hilfreich, um Unterklassen zu ermöglichen Methoden zuüberschreiben, ohne dabei Methodenaufrufe innerhalb der Klasse zu stören. ZumBeispiel:

class Mapping: def __init__(self, iterable): self.items_list = [] self.__update(iterable) def update(self, iterable): for item in iterable: self.items_list.append(item) __update = update # private Kopie der ursprünglichen update() Methodeclass MappingSubclass(Mapping): def update(self, keys, values): # erstellt update() mit neuer Signatur # macht aber __init__() nicht kaputt for item in zip(keys, values): self.items_list.append(item)

Beachte, dass die Ersetzungsregeln vor allem dazu gedacht sind, Unfälle zuvermeiden; es ist immernoch möglich auf einen solchen als privatgekennzeichneten Namen von aussen zuzugreifen und ihn auch zu verändern. Daskann in manchen Umständen sogar nützlich sein, beispielsweise in einem Debugger.

Beachte, dass Code, der von exec() oder eval() ausgeführt wird, denKlassennamen der aufrufenden Klasse nicht als die aktuelle Klasse ansieht. Diesähnelt dem Effekt der global-Anweisung, der ebenfalls sehr beschränktauf den Code ist, der zusammen byte-kompiliert wird. Die gleiche Begrenzunggilt für getattr(), setattr() und delattr(), sowie den direktenZugriff auf __dict__.

9.7. Kleinkram¶

Manchmal ist es nützlich einen Datentyp zu haben, der sich ähnlich demrecord in Pascal oder dem “struct” in C verhält und ein Container für einpaar Daten ist. Hier bietet sich eine leere Klassendefinition an:

class Employee: passjohn = Employee() # Eine leere Arbeitnehmerakte anlegen# Die Akte ausfüllenjohn.name = 'John Doe'john.dept = 'Computerraum'john.salary = 1000

Einem Stück Python-Code, der einen bestimmten abstrakten Datentyp erwartet, kannstattdessen oft eine Klasse übergeben werden, die die Methoden dieses Datentypsemuliert. Wenn man zum Beispiel eine Funktion hat, die Daten aus einemDateiobjekt formatiert, kann man eine Klasse mit den Methoden read() undreadline() definieren, die die Daten stattdessen aus einemZeichenkettenpuffer bekommt, und als Argument übergeben.

Methodenobjekte der Instanz haben auch Attribute: m.__self__ ist dasInstanzobjekt mit der Methode m() und m.__func__ ist das entsprechendeFunktionsobjekt der Methode.

9.8. Ausnahmen sind auch Klassen¶

Benutzerdefinierte Ausnahmen werden auch durch Klassen gekennzeichnet. Durch dieNutzung dieses Mechanismus ist es möglich erweiterbare Hierarchien vonAusnahmen zu erstellen.

Es gibt zwei neue (semantisch) gültige Varianten derraise-Anweisung:

raise Klasseraise Instanz

In der ersten Variante muss Class eine Instanz von type oder einerdavon abgeleiteten Klasse sein und ist eine Abkürzung für:

raise Klasse()

Die in einem except-Satz angegebene Klasse fängt Ausnahmen dann ab,wenn sie Instanzen derselben Klasse sind oder von dieser abgeleitet wurden,nicht jedoch andersrum — der mit einer abgeleiteten Klasse angegebeneexcept-Satz fängt nicht die Basisklasse ab. Zum Beispiel gibt derfolgende Code B, C, D in dieser Reihenfolge aus:

class B(Exception): passclass C(B): passclass D(C): passfor cls in [B, C, D]: try: raise cls() except D: print("D") except C: print("C") except B: print("B")

Beachte, dass B, B, B ausgegeben wird, wenn man die Reihenfolge umdreht, dasheisst zuerst except B, da der erste zutreffende except-Satzausgelöst wird.

Wenn eine Fehlermeldung wegen einer unbehandelten Ausnahme ausgegeben wird, wirdder Name der Klasse, danach ein Doppelpunkt und ein Leerzeichen und schliesslichdie Instanz mit Hilfe der eingebauten Funktion str() zu einer Zeichenketteumgewandelt ausgegeben.

9.9. Iteratoren¶

Mittlerweile hast du wahrscheinlich bemerkt, dass man über die meistenContainerobjekte mit Hilfe von for iterieren kann:

for element in [1, 2, 3]: print(element)for element in (1, 2, 3): print(element)for key in {'eins':1, 'zwei':2}: print(key)for char in "123": print(char)for line in open("meinedatei.txt"): print(line)

Diese Art des Zugriffs ist klar, präzise und praktisch. Der Gebrauch vonIteratoren durchdringt und vereinheitlicht Python. Hinter den Kulissen ruft diefor-Anweisung iter() für das Containerobjekt auf. Die Funktiongibt ein Iteratorobjekt zurück, das die Methode __next__() definiert,die auf die Elemente des Containers nacheinander zugreift. Gibt es keineElemente mehr, verursacht __next__() eine StopIteration-Ausnahme,die der for-Schleife mitteilt, dass sie sich beenden soll. Man kannauch die __next__()-Methode mit Hilfe der eingebauten Funktionnext() aufrufen. Folgendes Beispiel demonstriert, wie alles funktioniert.

>>> s = 'abc'>>> it = iter(s)>>> it<iterator object at 0x00A1DB50>>>> next(it)'a'>>> next(it)'b'>>> next(it)'c'>>> next(it)Traceback (most recent call last): File "<stdin>", line 1, in ? next(it)StopIteration

Kennt man die Mechanismen hinter dem Iterator-Protokoll, ist es einfach dasVerhalten von Iteratoren eigenen Klassen hinzuzufügen. Man definiert eine__iter__()-Methode, die ein Objekt mit einer __next__()-Methodezurückgibt. Definiert die Klasse __next__(), kann __iter__() einfachself zurückgeben:

class Reverse: """Iterator for looping over a sequence backwards.""" def __init__(self, data): self.data = data self.index = len(data) def __iter__(self): return self def __next__(self): if self.index == 0: raise StopIteration self.index = self.index - 1 return self.data[self.index]

>>> rev = Reverse('spam')>>> iter(rev)<__main__.Reverse object at 0x00A1DB50>>>> for char in rev:...  print(char)...maps

9.10. Generatoren¶

Generatoren (generator) sind eine einfache aber mächtige Möglichkeit umIteratoren zu erzeugen. Generatoren werden wie normale Funktionen geschrieben,benutzen aber yield, um Daten zurückzugeben. Jedes Mal wennnext() aufgerufen wird, fährt der Generator an der Stelle fort, an der erzuletzt verlassen wurde (der Generator merkt sich dabei die Werte allerVariablen und welche Anweisung zuletzt ausgeführt wurde). Das nachfolgendeBeispiel zeigt wie einfach die Erstellung von Generatoren ist:

def reverse(data): for index in range(len(data)-1, -1, -1): yield data[index]

>>> for char in reverse('golf'):...  print(char)...flog

Alles, was mit Generatoren möglich ist, kann ebenso (wie im vorigen Abschnittdargestellt) mit Klassen-basierten Iteratoren, umgesetzt werden. Generatorenerlauben jedoch eine kompaktere Schreibweise, da die Methoden __iter__()und __next__() automatisch erstellt werden.

Des weiteren werden die lokalen Variablen und der Ausführungsstand automatischzwischen den Aufrufen gespeichert. Das macht das Schreiben der Funktion einfacherund verständlicher als ein Ansatz, der mit Instanzvariablen wie self.indexoder self.data arbeitet.

Generatoren werfen automatisch StopIteration, wenn sie terminieren.Zusammengenommen ermöglichen diese Features die Erstellung von Iteratoren miteinem Aufwand, der nicht größer als die Erstellung einer normalen Funktion ist.

9.11. Generator Ausdrücke¶

Manche einfachen Generatoren können prägnant als Ausdrücke mit Hilfe einerSyntax geschrieben werden, die der von List Comprehensions ähnlich ist, jedochmit runden, statt eckigen Klammern. Diese Ausdrücke sind für Situationengedacht, in denen der Generator gleich von der umgebenden Funktion genutzt wird.Generator Ausdrücke sind kompakter, aber auch nicht so flexibel wie ganzeGeneratordefinitionen und neigen dazu speicherschonender als die entsprechendenList Comprehensions zu sein.

Beispiele:

>>> sum(i*i for i in range(10)) # Summe der Quadrate285>>> xvec = [10, 20, 30]>>> yvec = [7, 5, 3]>>> sum(x*y for x,y in zip(xvec, yvec)) # Skalarprodukt260>>> from math import pi, sin>>> sine_table = {x: sin(x*pi/180) for x in range(0, 91)}>>> unique_words = set(word for line in page for word in line.split())>>> valedictorian = max((student.gpa, student.name) for student in graduates)>>> data = 'golf'>>> list(data[i] for i in range(len(data)-1, -1, -1))['f', 'l', 'o', 'g']

Fußnoten