Klassen und Objektorientierung

Bisher hast du Daten in Variablen, Listen und Dicts abgelegt — und Funktionen darauf operieren lassen. Mit Klassen legst du Daten und die Funktionen, die mit ihnen arbeiten, gemeinsam in einer Einheit ab. Das ist Objektorientierung.

Das ist mehr als nur Aufräumen. Es macht zwei Sachen leichter:

1. Wiederverwendbarkeit. Ein Person-Klasse beschreibt einmal, was eine Person ist — du erzeugst hundert Instanzen davon, ohne den Code zu duplizieren.
2. Polymorphismus. Eine Superhero-Klasse kann von Person erben und nur die Unterschiede beschreiben. Der Code, der mit Persons arbeitet, funktioniert auch mit Superheros.

Quiz 05 prüft genau die fünf Stolpersteine, die HSG bei dieser Umstellung in den Vordergrund rückt: self, __init__, Vererbung, __str__ vs. __repr__, und der @property-Decorator. Diese Lektion isoliert sie.

Eine Klasse ist die Vorlage. Eine Instanz ist eine konkrete Ausprägung dieser Vorlage. Schau dir das Beispiel an:

class Person:
    def __init__(self, name, year_of_birth):
        self.name = name
        self.year_of_birth = year_of_birth

    def compute_age(self):
        return 2026 - self.year_of_birth

# Instanzen erzeugen — die Klasse wie eine Funktion aufrufen:
guido = Person("Guido van Rossum", 1956)
linus = Person("Linus Torvalds", 1969)

guido.name              # 'Guido van Rossum'
guido.compute_age()     # 70
linus.compute_age()     # 57

Drei Vokabeln, die du verinnerlichen solltest:

• Klasse (Person) — die Definition. Das Rezept.
• Instanz (guido) — ein konkretes Objekt, das nach dem Rezept gebaut wurde.
• Methode (compute_age) — eine Funktion, die zur Klasse gehört. Wird auf einer Instanz aufgerufen.

self ist die Instanz, auf der die Methode gerade läuft. Wenn du guido.compute_age() aufrufst, übersetzt Python das intern zu Person.compute_age(guido) — guido landet als erstes Argument im Parameter self.

Das erklärt zwei Sachen, die Anfänger verwirren:

1. Warum steht self als erster Parameter in der Methodendefinition? Damit die Methode weiß, auf welcher Instanz sie arbeitet. Ohne Parameter könnte sie nicht auf self.name zugreifen.
2. Warum schreibt man self nicht beim Aufruf? guido.compute_age() reicht — Python füllt self automatisch aus. Würdest du Person.compute_age(guido) schreiben (geht!), kommt guido direkt explizit rein.

__init__ ist die spezielle Methode, die Python aufruft, wenn du eine neue Instanz erzeugst. Sie initialisiert die Attribute. Die doppelten Unterstriche ("dunder") signalisieren: das ist Python-interne Magie, du redest hier mit dem Sprachkern.

class Book:
    def __init__(self, title, author, pages=200):
        self.title = title
        self.author = author
        self.pages = pages

# Aufruf:
b = Book("Dune", "Herbert")           # pages=200 per Default
b2 = Book("Solaris", "Lem", pages=350)

Drei Eigenschaften:

• __init__ gibt kein explizites Wert zurück — return self würde sogar einen Fehler werfen. Die neue Instanz wird implizit zurückgegeben.
• Defaults und Keyword-Arguments funktionieren genau wie bei normalen Funktionen (siehe Lektion 03).
• Du kannst auch Berechnungen im __init__ machen — self.created_at = datetime.now() ist häufig.

Eine Subklasse erbt von einer Superklasse. Sie übernimmt deren Methoden und Attribute, kann sie erweitern (mehr hinzufügen) und überschreiben (Verhalten ändern).

class Person:
    def __init__(self, name, year_of_birth):
        self.name = name
        self.year_of_birth = year_of_birth
    def compute_age(self):
        return 2026 - self.year_of_birth
    def __str__(self):
        return f"{self.name} ({self.compute_age()})"

class Superhero(Person):                    # ← erbt von Person
    def __init__(self, name, year_of_birth, alias, powerlevel):
        super().__init__(name, year_of_birth)   # ← Konstruktor der Superklasse aufrufen!
        self.alias = alias
        self.powerlevel = powerlevel

    def __str__(self):                        # ← überschreibt Person.__str__
        return f"{self.alias}: {self.powerlevel}"

hulk = Superhero("Bruce Banner", 1969, "Hulk", 600)
str(hulk)                # 'Hulk: 600'           — eigene __str__-Methode
hulk.compute_age()       # 57                     — Methode von Person geerbt
hulk.name                # 'Bruce Banner'         — Attribut von Person geerbt

super() greift auf die Superklasse zu — meist im __init__, um die geerbten Attribute korrekt zu initialisieren. Vergisst du das, fehlen die geerbten Attribute auf deiner Subklassen-Instanz.

In Python erbt jede Klasse — auch implizit — von der eingebauten Klasse object. Das heißt:

class A:
    pass

class B(A):
    pass

b = B()
isinstance(b, B)        # True
isinstance(b, A)        # True
isinstance(b, object)   # True — auch ohne dass es jemand explizit angibt

Wichtig fürs Quiz: Wenn dich jemand fragt "ist die Instanz einer Subklasse, die von einer Superklasse erbt, immer auch Instanz von object?" — die Antwort ist ja. Über die Vererbungskette landet jede Klasse irgendwann bei object.

Python ruft bestimmte Dunder-Methoden automatisch auf, wenn du Operationen wie print(...), str(...) oder den REPL-Echo-Output benutzt:

• __str__(self) → Was str(instance) und print(instance) zurückgeben.
• __repr__(self) → Was der REPL und Debug-Tools anzeigen. Sollte eindeutig sein, idealerweise so, dass eval(repr(x)) == x gilt.

class Person:
    def __init__(self, name, year):
        self.name, self.year = name, year
    def __str__(self):
        return f"{self.name} ({2026 - self.year})"
    def __repr__(self):
        return f"Person({self.name!r}, {self.year})"

guido = Person("Guido", 1956)
str(guido)                  # 'Guido (70)'
print(guido)                # Guido (70)
repr(guido)                 # "Person('Guido', 1956)"
guido                       # → REPL zeigt: Person('Guido', 1956)

Fallback-Regeln:

• Hat eine Klasse nur __repr__, aber kein __str__ → str(instance) benutzt __repr__.
• Hat sie weder noch → str(instance) zeigt etwas wie <__main__.Person object at 0x...>.

Der @property-Decorator macht eine Methode aussehen wie ein Attribut. Statt obj.compute_age() schreibst du obj.age — aber hinter den Kulissen läuft trotzdem dein Berechnungs-Code:

class Person:
    def __init__(self, name, year_of_birth):
        self.name = name
        self._year = year_of_birth          # Konvention: _ prefix = "intern"

    @property
    def age(self):
        return 2026 - self._year

    @property
    def year_of_birth(self):
        return self._year

p = Person("Guido", 1956)
p.age                    # 70  — wirkt wie Attribut, ist aber Methodenaufruf
p.year_of_birth          # 1956
p.year_of_birth = 1957   # AttributeError: can't set attribute  ← read-only by default!

@property macht die Methode lesbar wie ein Attribut, aber nicht schreibbar. Wer auch Schreiben erlauben will, definiert zusätzlich einen @<name>.setter-Decorator. Im HSG-Stoff brauchst du nur das Lesen.