Python Klassen/Objekte

Python ist eine objektorientierte Programmiersprache (OOP), die Code um Objekte herum organisiert, nicht nur um Funktionen. Eine Klasse ist der Bauplan, der beschreibt, welche Daten ein object enthält und was es tun kann. Ein object ist eine konkrete Instanz, die aus diesem Bauplan erstellt wurde.

Dieses Kapitel behandelt:

• Was Klassen und Objekte sind und warum sie wichtig sind
• Definition einer Klasse mit __init__, Instanzattributen und Methoden
• Klassenattribute versus Instanzattribute
• Erstellen und Verwenden von Objekten
• Ändern und Löschen von Attributen
• Typprüfung mit isinstance()
• Ein erster Blick auf Vererbung

Für eine ausführlichere Behandlung der Vererbung, siehe Python-Vererbung. Für fortgeschrittenere OOP-Muster, siehe Abstrakte Python-Basisklassen.

Was ist eine Klasse?

Stell dir eine Klasse wie eine Ausstechform und ein object wie den Keks vor. Du definierst die Form einmal (die Klasse) und stempelst dann so viele Kekse (Objekte) aus, wie du benötigst. Jedes object teilt dieselbe Struktur, enthält aber eigene Daten.

class Dog:
    pass  # an empty class — valid but not very useful yet

Das Schlüsselwort class, gefolgt von einem Namen und einem Doppelpunkt, erstellt eine neue Klasse. Konventionsgemäß verwenden Klassennamen CapWords (auch PascalCase genannt): MyClass, BankAccount, HttpRequest.

Die __init__-Methode

Die Methode __init__ (kurz für initialise) wird automatisch ausgeführt, jedes Mal wenn du ein neues object erstellst. Sie richtet den Anfangszustand des Objekts ein, indem sie Werte den Instanzattributen zuweist.

class Dog:
    def __init__(self, name, age):
        self.name = name   # instance attribute
        self.age = age     # instance attribute

Der erste Parameter ist immer self — er bezieht sich auf das object, das erstellt wird. Python übergibt ihn automatisch; du musst ihn nie selbst angeben.

Instanzattribute vs. Klassenattribute

class Dog:
    species = "Canis familiaris"  # class attribute — shared by all Dogs

    def __init__(self, name, age):
        self.name = name   # instance attribute
        self.age = age     # instance attribute

fido = Dog("Fido", 3)
bella = Dog("Bella", 5)

print(fido.species)    # Canis familiaris
print(bella.species)   # Canis familiaris  (same class attribute)
print(fido.name)       # Fido
print(bella.name)      # Bella             (different instance attributes)

Verwende ein Klassenattribut, wenn ein Wert für jedes object dieses Typs gleich ist (z. B. die Tierart aller Hunde). Verwende Instanzattribute für Daten, die je object variieren.

Methoden definieren

Eine Methode ist eine Funktion, die innerhalb einer Klasse definiert ist. Wie __init__ nimmt sie immer self als ersten Parameter, damit sie auf die eigenen Attribute des Objekts zugreifen kann.

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        return f"{self.name} says: Woof!"

    def description(self):
        return f"{self.name} is {self.age} years old."

Du rufst eine Methode auf einem object mit der Punktnotation auf — Python übergibt das object automatisch als self:

fido = Dog("Fido", 3)
print(fido.bark())          # Fido says: Woof!
print(fido.description())   # Fido is 3 years old.

Die __str__-Methode

Python ruft __str__ auf, wenn du ein object an print() oder str() übergibst. Ohne diese Methode erhältst du eine wenig hilfreiche Adresse wie <__main__.Dog object at 0x...>. Durch ihre Definition wird das Debugging deutlich einfacher.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Dog(name={self.name!r}, age={self.age})"

fido = Dog("Fido", 3)
print(fido)   # Dog(name='Fido', age=3)

Objekte erstellen und verwenden

Das Erstellen eines Objekts wird Instanziierung genannt. Du rufst die Klasse wie eine Funktion auf und übergibst alle Argumente, die __init__ erwartet (außer self):

Du kannst so viele Objekte wie nötig aus derselben Klasse erstellen — jedes ist unabhängig:

class Rectangle:
    def __init__(self, width, height=1):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

r1 = Rectangle(4, 3)
r2 = Rectangle(5)      # height defaults to 1

print(r1.area())        # 12
print(r1.perimeter())   # 14
print(r2.area())        # 5

Beachte, dass height=1 einen Standardwert bereitstellt: Wenn du das zweite Argument weglässt, verwendet Python automatisch 1.

Attribute ändern und löschen

Du kannst Attribute eines Objekts nach seiner Erstellung ändern oder hinzufügen und sie mit del löschen:

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

p = Person("Alice", 30)
print(p.age)      # 30

p.age = 31        # modify an existing attribute
print(p.age)      # 31

p.email = "[email protected]"   # add a new attribute at runtime
print(p.email)    # [email protected]

del p.email       # delete the attribute
# print(p.email)  # would raise AttributeError

Obwohl Python das freie Hinzufügen von Attributen erlaubt, ist es übersichtlicher, alle Attribute innerhalb von __init__ zu deklarieren, damit die Struktur der Klasse auf einen Blick ersichtlich ist.

Objekttypen prüfen

Verwende isinstance(), um zu prüfen, ob ein object eine Instanz einer bestimmten Klasse ist. Es gibt True zurück — sowohl für die Klasse selbst als auch für alle übergeordneten Klassen:

class Animal:
    pass

class Dog(Animal):
    pass

rex = Dog()
print(isinstance(rex, Dog))     # True
print(isinstance(rex, Animal))  # True  — Dog is a subclass of Animal
print(type(rex) is Dog)         # True
print(type(rex) is Animal)      # False — type() does not climb the hierarchy

Bevorzuge isinstance() gegenüber type() is im normalen Code, da es Unterklassen korrekt behandelt.

Ein erster Blick auf Vererbung

Vererbung ermöglicht es einer neuen Klasse, das Verhalten einer vorhandenen wiederzuverwenden und zu erweitern. Die neue Klasse (Kind- oder Unterklasse) erhält automatisch alle Attribute und Methoden der Elternklasse:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound."

class Dog(Animal):
    def speak(self):                     # override the parent method
        return f"{self.name} says: Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says: Meow!"

dog = Dog("Rex")
cat = Cat("Whiskers")
print(dog.speak())             # Rex says: Woof!
print(cat.speak())             # Whiskers says: Meow!
print(isinstance(dog, Animal)) # True

Sowohl Dog als auch Cat erben __init__ von Animal und müssen es daher nicht wiederholen. Sie überschreiben nur speak(), um rassenspezifisches Verhalten bereitzustellen.

Für eine vollständige Behandlung der Vererbung — einschließlich super(), Mehrfachvererbung und Method Resolution Order — siehe Python-Vererbung.

Wann solltest du eine Klasse verwenden?

Klassen sind am sinnvollsten, wenn:

• Du Daten und Verhalten hast, die zusammengehören (ein Bankkonto, das Ein- und Auszahlungen verwalten kann).
• Du mehrere unabhängige Objekte desselben Typs benötigst (viele Dog-Objekte, jedes mit unterschiedlichen Namen und Altersangaben).
• Du reale Entitäten modellieren möchtest, die eine klare Identität haben.

Einfache Hilfsfunktionen, die nur eine Eingabe in eine Ausgabe umwandeln, sind oft besser als normale Funktionen geeignet. Python schreibt nicht vor, dass alles in einer Klasse stehen muss.

Zusammenfassung

Übungen