Python unter Linux: Rund um OOP
Objektorientierte Programmierung ist die Vereinheitlichung der Konzepte
- Kapselung: Ein Objekt fasst alle benötigten Bestandteile zusammen, und verbirgt vor dem Nutzer den internen Aufbau. Stattdessen werden öffentliche Schnittstellen exportiert, auf die der Nutzer zugreifen kann.
- Vererbung: Ein Objekt kann Eigenschaften einer anderen Klasse im definierten Umfang erben. Einzelne Teile können dabei überschrieben werden.
- Polymorphie: Bezeichnet das Überladen von Operatoren und Methoden um eine einheitliche Schnittstelle für verschiedene Datentypen und Parameter zu haben.
Die typische Darstellung eines Objektes ist in Form einer Klasse. Funktionen, die innerhalb einer Klasse vereinbart werden, nennt man Methoden, Klassenvariablen nennt man Attribute. Wird ein Objekt erzeugt, so kann es unter Umständen eine Aktion wie das Initialisieren aller Daten ausführen. So eine Methode nennt man Konstruktor. Klassen speichert man typischerweise in eigenen Modulen.
Aufbau einer Klasse
BearbeitenDie einfachste Klasse tut gar nichts und enthält keinerlei Deklarationen:
#!/usr/bin/python
class TuNichts:
pass
objekt = TuNichts()
print dir(objekt)
print "Typ:", type(objekt)
Ausgabeuser@localhost:~$ ./klasse1.py
['__doc__', '__module__']
Typ: <type 'instance'>
Gefolgt vom Schlüsselwort class steht der Name der Klasse. Ein Objekt erzeugt man, in dem es aufgerufen wird. pass steht für: Tue wirklich gar nichts. Der Inhalt dieses Objektes kann mit dir() angezeigt werden. Diesen Typ Klasse nennt man Classic Classes. Sie sind mittlerweile veraltet, aber immer noch brauchbar und vor allem aus Gründen der Kompatibilität Standard. Hier das gleiche Beispiel als New-style Class:
#!/usr/bin/python
class TuNichts(object):
pass
objekt = TuNichts()
print dir(objekt)
print "Typ:", type(objekt)
Ausgabeuser@localhost:~$ ./klasse2.py
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__']
Typ: <class '__main__.TuNichts'>
Die Elternklassen werden in Klammern nach dem Klassennamen notiert. Wenn es mehrere Elternklassen sind, werden sie durch Kommata separiert. Unsere Klasse TuNichts erbt nun die Eigenschaften von object. Zur Vererbung kommen wir noch. Klassen neuen Typs haben einige Vorteile gegenüber Klassen alten Typs, wie zum Beispiel, dass sie sich nahtlos ins Typenkonzept von Python einfügen und einige typische Methoden mitbringen. Alle weiteren Beispiele in diesem Kapitel werden mit New-style-Klassen besprochen, die alte Variante sollten Sie aber wenigstens kennen.
Etwas mehr kann schon folgende Klasse:
#!/usr/bin/python
class TuEtwas(object):
def __init__(self, x):
self.x = x
def printX(self):
print self.x
objekt = TuEtwas(42)
objekt.printX()
Ausgabeuser@localhost:~$ ./klasse3.py
42
Diese Klasse enthält zwei Methoden, nämlich __init__() und printX(). __init__() wird aufgerufen, wenn ein Objekt der Klasse angelegt wird. Diese Methode muss nicht explizit aufgerufen werden. Das Argument self bezieht sich auf die Klasse selbst. self.x ist also eine Variable, die in der Klasse angelegt ist (Attribut), nicht als lokale Variable in den Methoden. Ruft eine Methode eine andere auf, so muss ebenfalls self vor den Methodenaufruf geschrieben werden.
Die folgende Klasse implementiert eine physikalische Größe, die Temperatur. Temperaturen werden in Grad Fahrenheit, Kelvin oder Grad Celsius gemessen, wobei wir nur die letzten beiden Einheiten berücksichtigen. Die Klasse speichert alle Temperaturen in Kelvin.
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Temperatur(object):
def __init__(self, Wert, Einheit = "K"):
if Einheit == "K":
self.temperatur = Wert
self.einheit = Einheit
elif Einheit == "°C":
self.temperatur = Wert + 273
self.einheit = "K"
else:
self.temperatur = 0
self.einheit = "K"
def umrechnen(self, Einheit = "K"):
if Einheit == "K":
return self.temperatur
elif Einheit == "°C":
return self.temperatur - 273
def ausgeben(self, Einheit = "K"):
if Einheit in ("K", "°C"):
print "Die Temperatur beträgt %.2f %s" % (self.umrechnen(Einheit), Einheit)
else:
print "unbekannte Einheit"
T1 = Temperatur(273, "K")
T1.ausgeben("°C")
T1.ausgeben("K")
T1.ausgeben("°F")
Ausgabeuser@localhost:~$ ./klasse4.py
Die Temperatur beträgt 0.00 °C
Die Temperatur beträgt 273.00 K
unbekannte Einheit
Die Klasse enthält drei Methoden, nämlich __init__(), den Konstruktor, umrechnen(), eine Methode, die von Kelvin in andere Einheiten umrechnen kann und die Methode ausgeben(), welche die aktuelle Temperatur als String ausgibt. Die Attribute dieser Klasse sind temperatur und einheit. In dieser Klasse sind alle Attribute öffentlich sichtbar und veränderbar.
Privat - mehr oder weniger
BearbeitenUm gegenüber den Nutzern einer Klasse anzudeuten, dass bestimmte Methoden oder Attribute privat sind, also nicht nach außen exportiert werden sollen, stellt man ihnen einen Unterstrich (_) voran. Echt privat sind solcherart gekennzeichneten Attribute nicht, es handelt sich hierbei mehr um eine textuelle Vereinbarung, wie folgendes Beispiel zeigt:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Quadrat(object):
def __init__(self, kantenlaenge = 0.0):
if kantenlaenge < 0.0:
self._kantenlaenge = 0.0
else:
self._kantenlaenge = kantenlaenge
def flaeche(self):
return self._kantenlaenge * self._kantenlaenge
Q1 = Quadrat(10)
print Q1.flaeche()
Q1._kantenlaenge = 4
print Q1.flaeche()
Ausgabeuser@localhost:~$ ./privat1.py
100
16
Es kann hier der Kantenlänge ein Wert zugewiesen werden, was vom Autor der Klasse sicher nicht beabsichtigt war. Das Attribut _kantenlaenge ist nur durch die Vereinbarung geschützt, an die man sich als Nutzer einer Klasse im Allgemeinen halten sollte.
Um noch stärker anzudeuten, dass Attribute privat sind, werden zwei Unterstriche verwendet. Auch hier kann man der Kantenlänge einen Wert zuweisen, er wird jedoch nicht berücksichtigt:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Quadrat(object):
def __init__(self, kantenlaenge = 0.0):
if kantenlaenge < 0.0:
self.__kantenlaenge = 0.0
else:
self.__kantenlaenge = kantenlaenge
def flaeche(self):
return self.__kantenlaenge * self.__kantenlaenge
Q1 = Quadrat(10)
print Q1.flaeche()
Q1.__kantenlaenge = 4
print Q1.flaeche()
Ausgabeuser@localhost:~$ ./privat2.py
100
100
In beiden Fällen ist die Fläche immer gleich, der Wert der Kantenlänge verändert sich trotz Zuweisung nicht. Das liegt daran, dass es Q1.__kantenlaenge gar nicht gibt. Bei der Zuweisung Q1.__kantenlaenge = 4 wird ein neues Klassenattribut erzeugt. Das eigentlich als privat deklarierte Attribut __kantenlaenge versteckt sich nun hinter dem Ausdruck _Quadrat__kantenlaenge. Dies können Sie leicht mit Hilfe der dir()-Funktion selbst überprüfen:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Quadrat(object):
def __init__(self, kantenlaenge = 0.0):
if kantenlaenge < 0.0:
self.__kantenlaenge = 0.0
else:
self.__kantenlaenge = kantenlaenge
def flaeche(self):
return self.__kantenlaenge * self.__kantenlaenge
Q1 = Quadrat(10)
print "Die Fläche beträgt: ", Q1.flaeche()
Q1.__kantenlaenge = 4
print "Q1.__kantenlaenge: ", Q1.__kantenlaenge
print "Die echte Kantenlänge: ", Q1._Quadrat__kantenlaenge
print "Q1 hat folgenden Inhalt:\n", dir(Q1)
Ausgabeuser@localhost:~$ ./privat3.py
Die Fläche beträgt: 100
Q1.__kantenlaenge: 4
Die echte Kantenlänge: 10
Q1 hat folgenden Inhalt:
['_Quadrat__kantenlaenge', '__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__kantenlaenge', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', 'flaeche']
Wie Sie sehen, haben wir mit der Zuweisung Q1.__kantenlaenge = 4 ein neues Attribut erzeugt, denn offenbar wurde dieses ja nicht für die Flächenberechnung herangezogen.
DetailsMachen Sie sich bitte keine allzu großen Gedanken über private Attribute und Methoden. Der Python way of coding ist da weniger streng als andere Sprachen. Stellen sie allem, was nicht nach außen hin sichtbar sein soll, einen Unterstrich voran, dann ist es privat genug. Diese Vereinbarung reicht Python-Programmierern im allgemeinen aus.
Getter und Setter
BearbeitenIn realen Programmen ist es sehr wichtig, einen konsistenten Zugriff auf die Klasse zu haben, so dass bei der Änderung von Attributen auch weiterhin alle Klassenattribute korrekte Werte haben. Probleme in diesem Bereich entstehen oft dadurch, dass Nutzer einer Klasse die Implementation nicht kennen oder kennen sollen. Der Zugriff auf Attribute erfolgt dann durch spezielle Methoden, die lediglich Attributwerte modifizieren oder zurückgeben. Diese nennt man getter und setter, sie holen oder setzen Werte. In objektorientierten Programmiersprachen, die keinen direkten Zugriff auf Klassenattribute ermöglichen, findet man daher oft triviale Methoden vor, die lediglich Werte setzen oder zurückgeben. Auch in folgendem Beispiel verwenden wir zwei solche eigentlich überflüssigen getter. Sie dienen dazu, Ihnen das Konzept vorzuführen und auf weitere Details später einzugehen.
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Quadrat(object):
def __init__(self, kantenlaenge = 0.0):
self.set_kantenlaenge(kantenlaenge)
def _berechne_flaeche(self):
self.__flaeche = self.__kantenlaenge * self.__kantenlaenge
def get_kantenlaenge(self):
return self.__kantenlaenge
def set_kantenlaenge(self, kantenlaenge):
if kantenlaenge < 0.0:
self.__kantenlaenge = 0.0
else:
self.__kantenlaenge = kantenlaenge
self._berechne_flaeche()
def get_flaeche(self):
return self.__flaeche
Q1 = Quadrat(10)
print Q1.get_flaeche()
Q1.set_kantenlaenge(12)
print Q1.get_flaeche()
Ausgabeuser@localhost:~$ ./getset1.py
100
144
Hier ist die Fläche ein weiteres Attribut, welches durch die Methode _berechne_flaeche() berechnet wird. Bei jedem Aufruf, der die Kantenlänge ändert, wird die Fläche neu bestimmt. In dieser Klasse gibt es zwar die Möglichkeit, die Kantenlänge zu modifizieren, nicht jedoch die Fläche. Ein direkter Zugriff auf die Attribute sollte dringend unterbleiben, deswegen wurden diese als stark privat gekennzeichnet. Möchte man sicher gehen, dass jeder Zugriff auf Attribute über die get- und set-Methoden abgewickelt wird, jedoch trotzdem auf den bequemen Zugriff per Objektvariablen zugreifen, so kann die Funktion property() helfen. Sie akzeptiert mindestens eine get- und set-Methode und liefert einen Namen für den Zugriff auf das Attribut:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Quadrat(object):
def __init__(self, kantenlaenge):
self.set_kantenlaenge(kantenlaenge)
def _berechne_flaeche(self):
self._flaeche = self._kantenlaenge * self._kantenlaenge
def get_kantenlaenge(self):
return self._kantenlaenge
def set_kantenlaenge(self, kantenlaenge):
if kantenlaenge < 0.0:
self._kantenlaenge = 0.0
else:
self._kantenlaenge = kantenlaenge
self._berechne_flaeche()
def get_flaeche(self):
return self._flaeche
kantenlaenge = property(get_kantenlaenge, set_kantenlaenge)
flaeche = property(get_flaeche)
Q1 = Quadrat(12)
print "Kantenlänge = ", Q1.kantenlaenge, " Fläche = ", Q1.flaeche
Q1.kantenlaenge = 9
print "Kantenlänge = ", Q1.kantenlaenge, " Fläche = ", Q1.flaeche
Ausgabeuser@localhost:~$ ./getset2.py
Kantenlänge = 12 Fläche = 144
Kantenlänge = 9 Fläche = 81
In diesem Code haben wir alle interessanten Getter und Setter eingefügt und am Ende der Klasse miteinander verwebt. Für das Attribut kantenlaenge sind also die Methoden get_kantenlaenge() und set_kantenlaenge() verantwortlich, die ihrerseits auf Attribute wie self._kantenlaenge zugreifen. Das Attribut flaeche hingegen kann nur gelesen werden, da der Setter für dieses Attribut fehlt. Properties werden innerhalb der Klasse, jedoch außerhalb aller Methoden deklariert.
Statische Methoden
BearbeitenMit statischen Methoden lassen sich Methodensammlungen anlegen, die sich nicht auf das jeweilige Objekt beziehen, sondern allgemeingültig formuliert sind. Damit nutzen sie auch Anwendern der Klasse, die kein Klassenobjekt benötigen.
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Rechteck(object):
def __init__(self, kante1, kante2):
self._kante1 = kante1
self._kante2 = kante2
def berechne_flaeche(a, b):
return a * b
flaeche = staticmethod(berechne_flaeche)
print Rechteck.flaeche(3, 5)
Ausgabeuser@localhost:~$ ./statisch1.py
15
Hier wird eine solche statische Methode namens flaeche() definiert. Die dahinterliegende Methode berechne_flaeche darf kein self-Argument mitführen, denn dieses bezieht sich ja gerade auf die Instanz der Klasse selbst. Es braucht ebenfalls kein Objekt von Typ Rechteck deklariert zu werden.
Selbiges Beispiel funktioniert auch noch etwas einfacher - wer hätte das gedacht. Hierbei bedienen wir uns einer so genannten Funktionsdekoration[1].
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Rechteck(object):
def __init__(self, kante1, kante2):
self._kante1 = kante1
self._kante2 = kante2
@staticmethod
def berechne_flaeche(a, b):
return a * b
print Rechteck.berechne_flaeche(3, 5)
Ausgabeuser@localhost:~$ ./statisch2.py
15
@staticmethod ist so eine Funktionsdekoration. Vor eine Methode geschrieben bewirkt sie, dass die nun folgende Methode als statisch anzusehen ist, also auch unabhängig vom erzeugten Objekt nutzbar ist.
Polymorphie
BearbeitenPolymorphie - das Überladen von Operatoren und Methoden - funktioniert in einem recht begrenzten Umfang. Einige Beispiele haben Sie dazu schon im Kapitel über Funktionen, Variable Parameter, kennengelernt. In diesem Abschnitt wollen wir uns daher auf das Überladen von Operatoren beschränken. Das folgende Programm überlädt die Operatoren für die Addition und die Multiplikation. Darüberhinaus ermöglicht uns das Programm, den Absolutbetrag eines Objektes zu bestimmen wie auch dieses Objekt in einen String zu verwandeln. Das Programmbeispiel implementiert dabei die physikalische Größe der Kraft, die in diesem Fall aus zwei Komponenten besteht, einer horizontalen Richtung und einer vertikalen.
#!/usr/bin/python
# -*- coding: utf-8 -*-
import math
class Kraft(object):
def __init__(self, kx, ky):
self._kx = kx
self._ky = ky
def __add__(self, F):
x, y = F.get()
return Kraft(self._kx + x, self._ky + y)
def __mul__(self, zahl):
return Kraft(self._kx * zahl, self._ky * zahl)
def get(self):
return (self._kx, self._ky)
def __abs__(self):
f2 = self._kx ** 2 + self._ky ** 2
return math.sqrt(f2)
def __str__(self):
return "Die Kraft ist (%.2f, %.2f), die Länge ist %.2f" % (self._kx, self._ky, abs(self))
F1 = Kraft(3, 4)
F2 = F1 * 3
print F1
print F2
print F1 + F2
Ausgabeuser@localhost:~$ ./poly11.py
Die Kraft ist (3.00, 4.00), die Länge ist 5.00
Die Kraft ist (9.00, 12.00), die Länge ist 15.00
Die Kraft ist (12.00, 16.00), die Länge ist 20.00
Wann immer ein Objekt mit einem anderen multipliziert werden soll, wird die entsprechende __mul__()-Methode des Objektes aufgerufen. Dies machen wir uns hier zu Nutze und definieren diese Methode einfach um. Selbiges geschieht bei der Addition, hier wird __add__() umdefiniert. Beide Funktionen geben ein neues Kraftobjekt zurück. Die __str__()-Methode wird immer aufgerufen, wenn ein Objekt in einen String umgewandelt werden soll, die Methode __abs__() wird aufgerufen, wenn der Absolutbetrag eines Objektes angefragt wird. Der Absolutbetrag unseres Objektes ist schlicht seine Länge. Es gibt noch mehr Operatoren und sonstige Klassenmethoden, die man individuell für Klassen definieren kann. Hierzu finden Sie im Internet Anleitungen.
Vererbung
BearbeitenMit Vererbung lassen sich aus recht allgemeinen Klasse spezialisierte Klassen erzeugen, die alle Eigenschaften der Elternklasse besitzen. Folgendes Beispiel verdeutlicht das Vorgehen:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Rechteck(object):
def __init__(self, seite1, seite2):
self._seite1 = seite1
self._seite2 = seite2
def flaeche(self):
return self._seite1 * self._seite2
class Quadrat(Rechteck):
def __init__(self, seite):
Rechteck.__init__(self, seite, seite)
Q1 = Quadrat(4)
print Q1.flaeche()
Ausgabeuser@localhost:~$ ./vererb1.py
16
Es wird zunächst eine allgemeine Rechteck-Klasse implementiert, die über die Fähigkeit verfügt, ihren Flächeninhalt zu berechnen. Die Spezialklasse Quadrat erbt sodann alle Eigenschaften von Rechteck, insbesondere die Fähigkeit, ihre Fläche nennen zu können. Die Elternklassen werden bei der Deklaration einer Klasse durch Kommata getrennt in die Klammern geschrieben. Für jede Basisklasse muss dann der Konstruktor aufgerufen werden, in unserem Fall Rechteck.__init__(self, seite, seite). Eine Klasse kann auch von mehreren Eltern erben. Als Beispiel dient eine studentische Hilfskraft in einer Firma. Diese ist selbstverständlich ein echter Studierender, hat also eine Matrikelnummer, jedoch auch ein echter Mitarbeiter der Firma, bezieht also ein Gehalt:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Student(object):
def __init__(self, MatNummer):
self._matnummer = MatNummer
def __str__(self):
return "Matrikelnummer: %d" % self._matnummer
class Mitarbeiter(object):
def __init__(self, Gehalt):
self._gehalt = Gehalt
def __str__(self):
return "Gehalt: %d" % self._gehalt
class Hilfskraft(Student, Mitarbeiter):
def __init__(self, Gehalt, MatNummer):
Mitarbeiter.__init__(self, Gehalt)
Student.__init__(self, MatNummer)
def gehalt(self):
return self._gehalt
def matnummer(self):
return self._matnummer
Hans = Hilfskraft(500, 12345)
print Hans.gehalt(), Hans.matnummer()
print Hans
Ausgabeuser@localhost:~$ ./vererb2.py
500 12345
Matrikelnummer: 12345
Die Elternklassen werden durch Kommata getrennt bei der Definition der Klasse aufgeführt. Wie wir bei der Ausführung des Codes sehen können, berücksichtigt die print Hans-Anweisung lediglich die __str__()-Methode der Klasse Student. Vertauschen Sie in der Klassendefinition die Reihenfolge von Student, Mitarbeiter, dann stellen Sie fest, dass immer diejenige __str__()-Methode der zuerst genannten Elternklasse ausgeführt wird. Möchte man beide oder eine bestimmte Methode der Eltern ausführen, so muss man eine eigene Methode schreiben:
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Student(object):
def __init__(self, MatNummer):
self._matnummer = MatNummer
def __str__(self):
return "Matrikelnummer: %d" % self._matnummer
class Mitarbeiter(object):
def __init__(self, Gehalt):
self._gehalt = Gehalt
def __str__(self):
return "Gehalt: %d" % self._gehalt
class Hilfskraft(Student, Mitarbeiter):
def __init__(self, Gehalt, MatNummer):
Mitarbeiter.__init__(self, Gehalt)
Student.__init__(self, MatNummer)
def __str__(self):
return Mitarbeiter.__str__(self) + " " + Student.__str__(self)
Hans = Hilfskraft(500, 12345)
print Hans
Ausgabeuser@localhost:~$ ./vererb3.py
Gehalt: 500 Matrikelnummer: 12345
Auf Elternklassen greift man über die Klassennamen (Student oder Mitarbeiter) zu, nicht über Objekte.
Zusammenfassung
BearbeitenIn diesem Kapitel haben Sie einen Überblick über die Fähigkeiten der objektorientierten Programmierung mit Python gewonnen. Sie wissen nun, wie man Klassen aufbaut und kennen einige typische Techniken im Umgang mit Methoden und Attributen. Ebenso haben wir gezeigt, wie in Python Vererbung, eine wichtige Technik der OOP, funktioniert.
Anmerkungen
Bearbeiten- ↑ engl.: function decorator
