Objektorientierte Programmierung

Objektorientierte vs. Prozeduale Programmierung¶

Stellen wir uns vor, wir möchten ein Programm für die Universitätsbibliothek schreiben, das Studierende und verfügbare Lehrbücher organisiert.

Zunächst betrachten wir, wie dies im prozeduralen Programmierstil aussehen könnte.

Eigenschaften von Studierenden könnten in einer Liste gespeichert werden:

Man könnte nun freie Funktionen definieren, die mit diesen Eigenschaften zusammen einen logischen Programmablauf realisieren:

Dieser Programmierstil birgt allerdings einige Nachteile. Wenn wir im späteren Programmcode den Studiengang eines Studierenden wechseln wollen, werden wir uns noch daran erinnern, dass dieser an 4. Stelle der Liste steht? Außerdem könnte die freie Funktion celebrate_birthday auch auf alle anderen Listen mit mindestens 3 Elementen und einer Zahl an dritte Stelle angewendet werden. Unser Bibliotheksprogramm könnte die Lehrbücher beispielsweise wie folgt speichern

und natürlich macht es keinen Sinn den Geburtstag einer Lehrbuchs zu feiern, dennoch würde unser Programm dies zulassen. Dann wird allerdings das Buch in das nächste Regal verschoben:

Hier wird das Alter des Studierenden korrekt erhöht, aber dieselbe Funktion könnte die Regalnummer eines Buchs ändern – was logisch unsinnig ist. Sinnvoll wäre es hier die Funktion celebrate_birthday direkt an Studierende zu koppeln. Im folgenden Abschnitt schauen wir uns eine objektorientierte Umsetzung unseres Programms an.

Klassen, Methoden und Attribute¶

Erstellen eigener Klassen¶

Die objektorientierte Programmierung ist ein Programmierstil bei dem spezifische Eigenschaften und darauf anwendbare Operationen in individuellen Objekten gebündelt.

So ein Objekt ist beispielsweise ein Student oder eine Studentin, ausgestattet mit individuellen Eigenschaften wie Name, Geschlecht, Alter, Studiengang, Fachsemester, Notendurchschnitt. Eine Studentin führt gewisse Aktionen aus, beispielsweise Altern, Atmen, Lernen, eine Prüfung ablegen, etc..

Die Idee der Objektorientierten Programmierung ist es, die Klassifizierung Student/in mit einem eigens dafür vorgesehenen Datentyp, einer sogenannten Klasse, zu assozieren. Diese Klasse soll die vorher festgelegten Eigenschaften und Operationen bereitstellen. Wir erinnern uns vielleicht noch an die vorangegangenen Kapitel. Wir hatten bereits mit einer Klasse für komplexe Zahlen gearbeitet.

Hier ist real ein Attribut und conjugate() eine Methode des Objekts c.

Attribute und Methoden sind bereits die wichtigsten Bestandteile einer Klasse. Wir wollen nun lernen eigene Klassen zu implementieren. Die allgemeine Syntax sieht wie folgt aus:

class <class_name>:
    def __init__(self, <param1>, <param2>, ...):
        self.<attribute_1> = ...
        self.<attribute_2> = ...
    
    def <method_1>(self, [parameter_list]):
        [do something]
        return <result>
    
    def <method_2>(self, [parameter_list]):
        [do something]
        return <result>  

Die Klassendefinition beginnt mit dem Schlüsselwort class, gefolgt vom Namen unserer Klasse. Innerhalb der Klassendefinition werden nun Funktionen definiert, die wir in diesem Kontext als Methoden bezeichnen. Methoden sind stets an eine Instanz (Objekt) dieser Klasse gekoppelt.

Eine spezielle Methode, die wir hier zunächst hervorheben wollen, ist die sogenannte Init-Funktion, auch Konstruktor genannt. Diese heißt immer __init__ und nimmt als Eingabeparameter das Objekt self entgegen und zusätzlich beliebig viele weitere Parameter. Ihre Aufgabe ist es, die Attribute der Klasse zu initialisieren - entweder mit Standardwerten oder abhängig von den Eingabeparametern.

Wir können anschließend im Hauptprogramm sogenannte Instanzen unserer Klasse erzeugen mit:

<instance> = <class_name>(<param1>, <param2>, ...)

Auf die Attribute der Klasse können wir innerhalb der Klasse (in einer Methode) mit

self.<attribute>

und von außerhalb der Klasse mit

<instance>.<attribute>

zugreifen und sie sowohl lesen als auch schreiben.

Ähnlich verhält es sich bei Methoden. Innerhalb der Klasse nutzen wir

self.<method>(<param1>, <param2>, ...)

und außerhalb

<instance>.<method>(<param1>, <param2>, ...)

Beispiel: Für die Verwaltung von Studierenden könnte eine objektorientierte Lösung zunächst folgende Klasse definieren:

Dieser Code erfordert eine ausführlichere Erläuterung:

• Wir haben eine Klasse namens student definiert.

• Die Klasse besitzt die Attribute name, sex, age, course, semester, marks, welche in der Init-Funktion zunächst initialisiert werden. Die Init-Funktion initialisiert die Attribute

  • name, sex, age werden anhand der Eingabeparameter gesetzt, mit der wir die Init-Funktion später aufrufen werden.

  • course, semester erhalten Default-Werte (course="nicht eingeschrieben" und semester=1 in der Parameterliste der Init-Funktion). Diese Werte werden verwendet, wenn der Parameter beim Aufruf weggelassen wird.

  • marks wird als leere Liste initialisiert und ist unabhängig von den Eingabeparametern.

• Die Klasse besitzt eine Methode:

  • celebrate_birthday.

Beachte: Bei allen Methoden einer Klasse ist der erste Funktionsparameter immer self, also der Zeiger auf die Instanz selbst. Beim Aufruf einer Funktion wird dieses Objekt nicht explizit übergeben.

Schauen wir uns nun an, wie wir mit unserer Klasse arbeiten können. Wir erzeugen zunächst 2 Instanzen dieser Klasse:

An der Konsolenausgabe erkennen wir, dass tatsächlich die Init-Funktion aufgerufen wurde. Somit sind auch die Attribute sinnvoll initialisiert.

Wir können beispielsweise Lisa’s Alter abfragen, also auf ein Attribut zugreifen:

Um eine Methode auf Lisa aufzurufen nutzen wir

Dies waren schon die wichtigsten Konzepte zu Klassen. Wir sollten an diesem Punkt Attribute und Methoden, sowie den Sinn der Init-Funktion verstanden haben.

Klassenattribute¶

Einige weitere Begriffe müssen wir noch einführen. Das, was wir bisher als Attribut bezeichnet haben, sollte eigentlich den Begriff Instanzattribut tragen, denn es ist an eine bestimmte Instanz unserer Klasse gekoppelt. Eine weitere Art von Attribut ist das sogenannte Klassenattribut (auch Klassenvariable). Ein Klassenattribut ist eine Variable, die sich alle Instanzen einer Klasse teilen. Ein Klassenaatribut wird im Rumpf einer Klasse definiert

class <class_name>:
    <class_attribute> = <value>

und sowohl innerhalb als auch außerhalb der Klasse mit

<value> = <class_name>.<class_attribute>
<class_name>.<class_attribute> = <value>

gelesen bzw. geschrieben. Wir können beispielsweise unsere student-Klasse um ein Klassenattribut namens count erweitern, mit dem wir später die Anzahl der immatrikulierten Studierenden zählen können. Der Counter soll in der Init-Funktion erhöhrt und im Gegenstück, der Delete-Funktion oder auch Destruktor (diese wird aufgerufen, wenn ein Objekt zerstört wird) verringert wird. Wir könnten im Jupyter-Notebook die Zelle, in der wir die Klasse student definiert haben, editieren, oder die Klasse durch die rekursive Klassendefinition class student(student) um eine Methode erweitern, bzw. eine bestehende Methode ersetzen:

Wir erzeugen wieder 2 Instanzen der Klasse student, lesen das Klassenattribut count, löschen einen Studenten, und lesen das Klassenattribut erneut:

Wir fassen zunächst die gelernten Begriffe zusammen:

Auf Instanzvariablen kann man mit folgender Syntax zugreifen:

<instanz>.<locale variable>

Methoden ruft man auf mit:

<instanz>.<function>(<param1>, <param2>, ...)

Wir haben bereits spezielle Methoden kennengelernt, die nicht explizit aufgerufen werden, sondern automatisch bei bestimmten Ereignissen ausgeführt werden:

Als Übung fügen wir nun noch einige Funktionen zu unserer Klasse hinzu:

Da wir die Klasse student verändert haben, müssen wir die Instanz lisa nochmal neu anlegen. Für diese Instanz können wir nun Prüfungsnoten hinzufügen und den Notendurchschnitt berechnen lassen:

Wenn ein Name wie lisa bereits auf ein bestehendes Objekt verweist, wird bei der erneuten Zuweisung ein neues Objekt erstellt. Das vorherige Objekt wird nicht mehr referenziert und Python ruft automatisch den Destruktor __del__ auf. So wird z. B. die Exmatrikulation angezeigt, wenn das alte Objekt gelöscht wird.

Spezielle Methoden¶

Schauen wir uns nochmals die Init-Funktion __init__ an. Diese wird nicht explizit aufgerufen, sondern automatisch bei der Initialisierung einer Klasseninstanz über student(...). Es gibt noch weitere solcher speziellen Methoden, die, falls sie in der Klasse implementiert sind, die Arbeit mit der Klasse eleganter gestalten.

Konsolenausgabe einer Instanz:

Wenn wir die Instanz lisa einfach auf der Konsole ausgeben, erhalten wir standardmäßig nur eine Speicheradresse und die Klasseninformation:

Wünschenswert wäre eine schön formatierte Ausgabe mit Namen, Alter, Geschlecht etc.

Wir erweitern die Klasse um Methoden, die die Ausgabe steuern:

• __str__ wird bei print(<instanz>) aufgerufen.

• __repr__ wird bei direkter Eingabe der Instanz in der Konsole ausgeführt.

Die eigentliche String-Konvertierung ist in __to_string__ ausgelagert, um Code-Duplikation zu vermeiden.

Nach dieser Modifikation erhalten wir die gewünschten Ausgaben auf der Konsole:

Methoden mit doppeltem Unterstrich (__to_string__) sind privat, d.h. sie sollen nur innerhalb der Klasse verwendet werden. Zwar kann man von außen lisa.__to_string__() aufrufen, dies gilt jedoch als schlechte Praxis.

Vergleichsoperationen:

Ferner sind Vergleichsoperationen interessant. Wir möchten möglicherweise:

• Personen nach Namen sortieren (<)

• doppelt angelegte Instanzen erkennen (==)

Damit solche Operationen funktionieren, müssen die entsprechenden Methoden in der Klasse definiert werden. Für die Vergleichsoperatoren implementiert man:

• __lt__(self, other) – “less than” (<)

• __le__(self, other) – “less or equal” (<=)

• __eq__(self, other) – “equal” (==)

Alle diese Funktionen müssen boolsche Werte zurückgeben, also True, wenn der Vergleich zutrifft, und False, wenn nicht.

Für unsere student-Klasse könnte eine Implementierung wie folgt aussehen:

Da wir __lt__ und __le__ definiert haben, können wir automatisch auch > bzw. >= verwenden.

Sobald eine Vergleichsoperation implementiert ist, kann man Listen von Instanzen nach Name sortieren:

Dank der vorher implementierten __str__- bzw. __repr__-Methoden wird bei der Ausgabe der Liste eine gut lesbare Darstellung der Studierenden verwendet.

Überladung von Operatoren¶

Auch die üblichen Rechenoperationen lassen sich für eigene Klassen definieren. Wie schon im Kapitel Lineare Algebra mit NumPy gesehen, sind Addition, Subtraktion, Multiplikation und Division für Instanzen vom Typ numpy.ndarray implementiert.

Für eigene Klassen kann man diese Operationen durch spezielle Methoden realisieren. Für die Addition (+) implementiert man z.B. die Methode

__add__(self, other)

Da die Addition zweier Studierender wenig Sinn macht, wechseln wir hier das Beispiel und implementieren eine eigene Klasse für komplexe Zahlen.

In folgendem Beispiel werden zwei komplexe Zahlen angelegt, addiert und das Ergebnis auf der Konsole ausgegeben:

In der folgenden Tabelle sind weitere vordefinierte Methoden zur Operatorüberladung zusammengefasst:

Vererbung¶

Bei der Vererbung übernimmt eine Klasse die Eigenschaften und Methoden einer anderen Klasse und ergänzt diese gegebenenfalls durch weitere Attribute und Methoden. Dies ist besonders sinnvoll, wenn mehrere Klassen viele gemeinsame Eigenschaften teilen.

Die Syntax zur Ableitung einer Klasse lautet:

class <sub_class>(<base_class>):
    [...]

Als Beispiel betrachten wir

• Die Klassenattribute description und region existieren sowohl in der Basisklasse animal als auch in den abgeleiteten Klassen fish und mammal.

• Für Objekte der abgeleiteten Klassen nehmen die Klassenattribute stets den Wert der abgeleiteten Klasse an.

• Die Methode __str__ muss nur einmal in der Basisklasse definiert werden, um für alle Objekte gültig zu sein.

Überschreiben von Methoden (Override):

Wenn wir die Methode __str__ in der abgeleiteten Klasse erneut implementieren, überschreibt diese die Implementierung der Basisklasse für Objekte dieser abgeleiteten Klasse. Wir können dennoch mit animal.__str__ explizit auf die Basisklassen-Implementierung zugreifen:

Python erlaubt natürlich auch mehrere Ebenen der Vererbung.
Wir könnten von unserer Klasse für Säugetiere weitere Klassen ableiten, z.B. für Nagetiere, Huftiere, etc.

Darüber hinaus ist auch Mehrfachvererbung möglich. Möchten wir eine Klasse von zwei oder mehreren Basisklassen ableiten, verwenden wir die Syntax:

class <sub_class>(<base_class_1>, <base_class_2>[, ...]):
    [...]

Die neue Klasse erbt dann alle Eigenschaften und Methoden von <base_class_1> und <base_class_2>. Kritisch wird es nur, wenn beide Basisklassen Methoden mit gleichem Namen aber unterschiedlicher Implementierung bereitstellen:

• centaur erbt von horse und human.

• Beim Aufruf von a.output() wird die Methode der ersten Basisklasse (horse) verwendet.

• Python verwendet hier die sogenannte Method Resolution Order (MRO), d.h. die Reihenfolge, in der Basisklassen durchsucht werden, um eine Methode zu finden.

• Problematisch wird es nur, wenn Konstruktoren (__init__) komplexe Logik enthalten; in diesem Fall muss man häufig die Basisklassen explizit aufrufen, z.B. horse.__init__(self) oder super().__init__().

Iteratoren¶

Wir haben schon einige Datentypen gesehen, über die wir in einer for-Schleife iterieren können, beispielsweise list, tuple, string. Man kann auch selbst programmierte Klassen iterierbar machen. Dafür müssen zwei Methoden implementiert werden:

• __iter__(self): Initialisiert den Iterator und gibt das aktuelle Objekt selbst zurück.

• __next__(self): Gibt das Nachfolgeelement der Iteration zurück oder wirft die Exception StopIteration

Beispiel: Lottozahlen 6 aus 49

Diese beiden Funktionen reichen aus, um das Objekt in einer for-Schleife zu verwenden:

Ein iterierbares Objekt lässt sich auch wie folgt manuell durchgehen:

Das Konstrukt bestehend aus try und except dient zum Exception-Handling. Python versucht den Block unter try auszuführen. Sobald eine Exception auftritt (hier StopIteration in LotteryNumbers.__next__), wird der except-Block ausgeführt.

Code-Dokumentation¶

Damit es potenziellen Anwendern unserer selbst programmierten Klassen einfacher fällt, ist eine ordentliche Code-Dokumentation sehr hilfreich.
Wir können die Klasse selbst sowie alle Methoden mit Docstrings versehen, also Kommentaren der Form:

"""
[Kommentar]
...
[Kommentar]
"""

Dieser Text erscheint dann im Hilfetext im Jupyter Lab, wenn wir mit ? nach der Dokumentation einer Klasse oder Methode fragen.

Beispiel: Dokumentierte Klasse

Wir bekommen nun mit

Car?

unsere Klassendokumentation angezeigt und mit

Car.engine_status?

die Dokumentation der engine_status-Methode.