• Konstruktoren
• Objekte und Referenzen
• Ein eigener Binärbaum
• Übungsaufgaben

Eine Klasse definiert einen Datentyp, der aus mehreren Daten-Bestandteilen bestehen kann. So besteht ein Datum aus Tag, Monat und Jahr und ein Bruch aus Zähler und Nenner. Das müssen keine ganzzahligen Werte sein, sondern durchaus auch Strings oder komplexere Typen, ja sogar weitere Klassen.

Zu einem Datentyp gehört aber auch oft eine spezielle Funktionalität. So ist das Addieren zweier ganzer Zahlen anders umzusetzen als das Addieren von Brüchen oder gar von einem Datum mit einer ganzen Zahl. Aus diesem Grund definiert eine Klasse auch Funktionalitäten.

Damit gehören zu einem Objekt sowohl die Datenbestandteile, die man auch als Attribut bezeichnet, als auch die Funktionen, die auf das Objekt angewandt werden können. Diese Funktionen, die auf Objekte angewandt werden, nennt man Methoden.

Eine Klasse ist die Definition eines Objekts. Sie beschreibt also dessen Attribute und Methoden. Ein Objekt ist die Instanz einer Klasse oder, weniger hochtrabend ausgedrückt, die Variable vom Typ einer Klasse.

Eine selbstgebastelte Kiste

class Kiste:
    breite = 0
    hoehe  = 0
    tiefe  = 0
    def getVolumen(self):
        vol = self.breite*self.hoehe*self.tiefe
        return vol

Um ein Objekt anzulegen, wird es mit dem Klassennamen gefolgt von einem Klammerpaar initialisiert. Hier wird ein Objekt meinekiste der Klasse Kiste angelegt.

Anschließend kann auf die Attribute und die Methoden des Objekts über den Objektnamen zugegriffen werden. Zur Trennung wird ein Punkt dazwischengestellt.

meinekiste = Kiste()
meinekiste.breite = 1
meinekiste.hoehe = 2
meinekiste.tiefe = 3
print(meinekiste.getVolumen()) # gibt 6 aus

Konstruktoren

class Kiste:
    def __init__(self):
        self.breite = 0
        self.hoehe = 0
        self.tiefe = 0
    def getVolumen(self):
        vol = self.breite*self.hoehe*self.tiefe
        return vol

Der Selbstbezug self

Sie können auch Konstruktoren mit Parametern definieren. Dann können Sie gleich bei der Erzeugung bereits Werte übergeben, mit denen ein Objekt initialisiert werden soll.

Konstruktoren können auch weitere Parameter erhalten, die zur Initialisierung von Member-Variablen verwendet werden können.

class Kiste:
    def __init__(self, b, h, t):
        self.breite = b
        self.hoehe = h
        self.tiefe = t
    def getVolumen(self):
        vol = self.breite*self.hoehe*self.tiefe
        return vol

k = Kiste(2,3,4)
print(k.getVolumen()) # gibt 24 aus

Destruktor

Objekte und Referenzen

Als Beispiel verwenden wir die Klasse Auto. Unser vereinfachtes Auto hat einen Modellnamen und eine Leistung, gemessen in PS. Methoden ersparen wird uns erst einmal.

class Auto:
    name = ""
    ps = 0

class Auto:
    def __init__(self):
        self.name = ""
        self.ps = 0

class Auto:
    def __init__(self, name, ps):
        self.name = name
        self.ps = ps

r4 = Auto("R4", 34)

a4 = Auto("A4", 102)

print(r4.name)  # zeigt R4
print(r4.ps)    # zeigt 34
print(a4.name)  # zeigt A4
print(a4.ps)    # zeigt 102

a4 = r4
a4.ps = 102
print(r4.ps)

Wozu Referenzen gut sind

class Auto:
    def __init__(self, name, ps):
        self.name = name
        self.ps = ps
        self.next = None

Nun erstellen wir einen R4, dann einen A4 und hängen den A4 hinten an den R4 an.

r4 = Auto("R4", 34)
a4 = Auto("A4", 102)
r4.next = a4
print(r4.next.name) # zeigt A4
print(r4.next.ps)   # zeigt 102

Referenz auf das gleiche Element? is

print(r4.next is a4) # gibt True aus
print(r4 is a4) # gibt False aus

Gar keine Referenz: None

if a4.next:
   print(a4.next.name)
else:
   print("Ende der Schlange")

Eine Kopie erstellen

from copy import copy

a5 = copy(a4)
a5.ps=120
print(a4.ps) # zeigt 102

Ein eigener Datencontainer: Der Binärbaum

Ein binärer Baum enthält Knoten, die mit je einer Referenz auf das nächstkleinere und das nächstgrößere Element verweisen. Kommt ein neues Element hinzu, wird zunächst die Stelle gesucht, wo das neue Element hingehört und dort ein Knoten eingefügt. Für das Auslesen eines Baumes werden rekursive Funktionen . eingesetzt, also Funktionen, die sich selbst aufrufen.

Die Klasse Baum stellt auf den ersten Blick nicht einen kompletten Baum dar, sondern nur einen Knoten. Dieser ist eher ein kleiner Ast, der einen Dateninhalt, einen Arm nach links und nach rechts besitzt. Werden neue Knoten an die Arme angefügt, entsteht ein Geflecht, das leichter als Baum identifiziert werden kann.

Rekursives Durchlaufen

Ein leerer Baum wird daran erkannt, dass der erste Knoten noch keinen Inhalt hat. Dies muss beim Bearbeiten des Baums also immer noch extra geprüft werden, bevor der rekursive Abstieg beginnt.

#!/usr/bin/python

class Baum:
    def __init__(self):
        self.__links = None
        self.__rechts = None
        self.__inhalt = None

    def einhaengen(self, inhalt):
        if self.__inhalt: # Baum ist nicht leer
            if self.__inhalt > inhalt: # sortiertes Einhaengen
                if self.__links:
                    self.__links.einhaengen(inhalt)
                else:
                    self.__links = Baum()
                    self.__links.__inhalt = inhalt
            else:
                if self.__rechts:
                    self.__rechts.einhaengen(inhalt)
                else:
                    self.__rechts = Baum()
                    self.__rechts.__inhalt = inhalt
        else: # Der Baum ist leer
            self.__inhalt = inhalt

    def anzeigen(self):
        if self.__links:   # links absteigen
            self.__links.anzeigen()
        if self.__inhalt:  # Sicherheitstest: Baum leer?
            print(self.__inhalt) # Aktion: Anzeigen
        if self.__rechts:  # rechts absteigen
            self.__rechts.anzeigen()

baum = Baum()
for i in "Bier", "Auto", "Schiff", "Wolke", "Pirat":
    baum.einhaengen(i)
baum.anzeigen()

Einbau einer Besucherfunktion

Ein flexibler Ansatz besteht darin, der Funktion anzeigen() eine Funktion in den Parametern durchzureichen, die sie dann anstelle des print-Aufrufs ausführt. Da die Funktion dann nicht mehr anzeigt, nennen wir sie in tuwas() um.

class Baum:
    # ...
    def tuwas(self, funktion):
        if self.__links:   # links absteigen
            self.__links.anzeigen()
        if self.__inhalt:  # Sicherheitstest: Baum leer?
            funktion(self.__inhalt) # Aktion: funktion
        if self.__rechts:  # rechts absteigen
            self.__rechts.anzeigen()

def zeigmal(a):
    print(a)

# ...
baum.tuwas(zeigmal)

Übungsaufgaben

Autokennzeichen

1. Sorgen Sie dafür, dass es bei der Erstellung des Autos eingegeben werden muss.
2. Ändern Sie die Klasse so, dass ein Kennzeichen angegeben werden kann, aber nicht muss. Wird bei der Erstellung des Autos kein Kennzeichen angegeben, soll "A-BC 123" verwendet werden.

Die Autovermietung

Erstellen Sie eine Klasse Tunnel, das Autos aufnimmt und diese in umgekehrter Weise wieder herausgibt.