Vererbung in Python: Eine Anleitung mit Drachen und Kühen – Lab 8 Praxis

Einführung in die Vererbung mit Python

In diesem Tutorial lernst du die Grundlagen der Vererbung in Python kennen. Vererbung ist ein zentrales Konzept der objektorientierten Programmierung (OOP), mit dem du neue Klassen auf Basis vorhandener Klassen erstellen kannst. Das spart Zeit, reduziert Redundanz und macht deinen Code wartbarer. Wir nutzen ein bekanntes Beispiel aus dem Lab 8 der Universität: eine Cowsay-ähnliche Anwendung mit Drachen und Kühen. Stell dir vor, du entwickelst ein kleines Spiel, in dem verschiedene Kreaturen Nachrichten anzeigen – genau wie in der Programmierung von textbasierten Abenteuern.

Warum Vererbung wichtig ist

In der heutigen Softwareentwicklung werden oft komplexe Systeme mit vielen ähnlichen Objekten gebaut. Denk an eine KI-App, die verschiedene Chatbot-Charaktere hat – jeder mit eigener Persönlichkeit, aber alle teilen grundlegende Funktionen. Oder an ein Finanz-Dashboard, das verschiedene Kontotypen verwaltet. Vererbung hilft dir, gemeinsame Eigenschaften in einer Basisklasse zu definieren und spezielle Erweiterungen in Unterklassen hinzuzufügen.

Das Cowsay-Beispiel: Von der Kuh zum Drachen

Unser Ausgangspunkt ist eine Cow-Klasse, die einen Namen und ein Bild (als ASCII-Art) speichert. Die Methoden sind: __init__(self, name), get_name(), get_image() und set_image(). Daraus leiten wir eine Dragon-Klasse ab, die zusätzlich die Methode can_breathe_fire() besitzt. Für den IceDragon überschreiben wir diese Methode, um False zurückzugeben. Dieses einfache Szenario zeigt, wie du durch Klassenhierarchien unterschiedliches Verhalten erzeugen kannst.

Schritt 1: Die Cow-Klasse

Erstelle eine Datei cow.py mit folgendem Code:

class Cow:
    def __init__(self, name):
        self.name = name
        self.image = None

    def get_name(self):
        return self.name

    def get_image(self):
        return self.image

    def set_image(self, image):
        self.image = image

Diese Klasse ist die Basis für alle Tiere. Der Konstruktor setzt den Namen und initialisiert das Bild als None. Später wird das Bild durch eine ASCII-Art ersetzt.

Schritt 2: Die Dragon-Klasse (abgeleitet von Cow)

In dragon.py importieren wir die Cow-Klasse und erstellen eine Unterklasse:

from cow import Cow

class Dragon(Cow):
    def __init__(self, name, image):
        super().__init__(name)
        self.set_image(image)

    def can_breathe_fire(self):
        return True

Mit super() rufen wir den Konstruktor der Elternklasse auf. Der Drache kann standardmäßig Feuer speien – can_breathe_fire() gibt True zurück. Diese Methode ist spezifisch für Drachen und existiert nicht in der Cow-Klasse.

Schritt 3: Die IceDragon-Klasse (abgeleitet von Dragon)

In ice_dragon.py:

from dragon import Dragon

class IceDragon(Dragon):
    def __init__(self, name, image):
        super().__init__(name, image)

    def can_breathe_fire(self):
        return False

Der IceDragon überschreibt die Methode, sodass er kein Feuer speien kann. Durch diese Methodenüberschreibung (Polymorphie) können wir unterschiedliche Drachenarten erstellen, ohne den gesamten Code neu zu schreiben.

Das Hauptprogramm: cowsay.py

Die Datei cowsay.py ist der Einstiegspunkt. Sie verarbeitet Kommandozeilenargumente mit sys.argv. Hier ein Ausschnitt:

import sys
from cow import Cow
from dragon import Dragon
from ice_dragon import IceDragon

def main():
    args = sys.argv[1:]
    if len(args) == 0:
        print("Usage: python3 cowsay.py [-l] [-n COW] MESSAGE")
        return
    if args[0] == "-l":
        # Liste verfügbarer Kühe anzeigen
        print("Cows available: heifer kitteh dragon ice-dragon")
    elif args[0] == "-n":
        if len(args) < 3:
            print("Missing arguments")
            return
        cow_name = args[1]
        message = args[2]
        # Hier müsste eine Factory oder ein Dictionary stehen, um das richtige Objekt zu erzeugen
        # Für das Tutorial zeigen wir nur die Struktur
    else:
        message = args[0]
        # Standardkuh verwenden

if __name__ == "__main__":
    main()

In der Praxis würdest du eine Factory-Methode verwenden, die anhand des Namens das passende Objekt erstellt. So wird die Wartbarkeit erhöht.

Praktische Tipps für dein Lab

• Dateistruktur: Halte jede Klasse in einer eigenen Datei – das erleichtert die Übersicht.
• Testen: Teste jede Klasse einzeln, bevor du sie kombinierst. Nutze if __name__ == "__main__" für schnelle Tests.
• Fehlerbehandlung: Wenn ein unbekannter Kuhname eingegeben wird, gib eine entsprechende Meldung aus (wie im Beispiel: „Could not find ninja cow!“).
• ASCII-Art: Verwende mehrzeilige Strings für die Bilder. Achte auf korrekte Einrückung.

Beispielausgabe verstehen

Die geforderte Ausgabe ist exakt vorgegeben. Wenn du python3 cowsay.py -n dragon "Firey RAWR" ausführst, erscheint zuerst die Sprechblase mit der Nachricht, dann das Drachenbild und schließlich der Satz „This dragon can breathe fire.“ Analog für den IceDragon: „This dragon cannot breathe fire.“

Dieses Lab ist eine hervorragende Übung, um Vererbung und Polymorphie zu verstehen. Es zeigt, wie du mit wenigen Zeilen Code flexible Strukturen aufbauen kannst.

Verbindung zu aktuellen Trends

Stell dir vor, du entwickelst einen Chatbot für eine Spieleplattform: Jeder Bot hat eine Persönlichkeit (Kuh, Drache, Eisdrache). Die Basisklasse enthält gemeinsame Funktionen wie Senden/Empfangen von Nachrichten, die Unterklassen fügen spezifische Reaktionen hinzu. Ähnlich arbeiten moderne KI-Assistenten wie Siri oder Alexa, die auf generischen Sprachmodellen aufbauen und durch spezielle Skills erweitert werden. Auch in der Finanzwelt werden Vererbungshierarchien genutzt: Ein Basiskonto (Konto) wird zu Girokonto, Sparkonto oder Depot erweitert. Sogar in Sport-Turnieren wie der Champions League könntest du eine allgemeine Mannschaftsklasse definieren und spezielle Spielstile ableiten. Die Prinzipien bleiben gleich.

Häufige Fehler vermeiden

• Vergessen von super(): Wenn du den Konstruktor der Elternklasse nicht aufrufst, werden Attribute nicht initialisiert.
• Falsche Importe: Achte darauf, dass die Dateipfade stimmen und du die Klassen korrekt importierst.
• Methodensignaturen: Überschreibst du eine Methode, muss sie exakt denselben Namen und Parameter haben (außer du nutzt optionale Parameter).

Fazit

Mit diesem Tutorial hast du die Grundlagen der Vererbung in Python gelernt. Du kannst nun eigene Klassenhierarchien entwerfen und Code-Wiederverwendung effektiv einsetzen. Das Cowsay-Lab ist ein klassisches Beispiel, das dir zeigt, wie Theorie in der Praxis angewendet wird. Viel Erfolg bei deiner Abgabe!