Objektorientierte Programmierung in Python
In dieser Lektion lernst du Kapselung, Vererbung, das Überschreiben von Methoden und Polymorphie an einem Bankkonto-Beispiel in Python kennen.
Was ist objektorientierte Programmierung in Python?
Das Problem
Wenn ein Programm wächst, brauchst du an vielen Stellen ähnliche Objekte mit kleinen Unterschieden: ein normales Konto und ein Sparkonto, eine Katze und einen Hund. Klassen zu kopieren und ein paar Zeilen zu ändern führt zu doppeltem Code. Und wenn du überall mit if den Typ prüfst, wird jede neue Art zu einem großen Umbau.
Stell es dir so vor
Objektorientierte Programmierung funktioniert wie die Konten bei einer Bank. Jedes Konto verwahrt seinen Kontostand hinter dem Schalter (Kapselung). Ein Sparkonto ist ein normales Konto mit einer Zusatzfunktion (Vererbung). Wenn die Bank allen Konten den Monatsabschluss ankündigt, erledigt ihn jedes Konto auf seine eigene Art (Polymorphie).
self._balance🔒 Das Geld hinter dem Schalter: nur über deposit() ändernclass SavingsAccount(BankAccount):🏦 Ein Sparkonto ist ein Konto mit Zinsen obendraufsuper().__init__(owner, balance)📋 Zuerst das normale Kontoformular ausfüllenaccount.month_end()📅 Dieselbe Anfrage, jedes Konto antwortet auf seine ArtObjektorientierte Programmierung gliedert ein Programm in Klassen, deren Objekte ihre Daten privat halten (Kapselung), andere Klassen wiederverwenden (Vererbung) und auf denselben Aufruf auf ihre eigene Art reagieren (Polymorphie).
OOP modelliert ein System als zusammenarbeitende Objekte. Jedes Objekt verbindet Zustand mit zulässigen Operationen und schafft dadurch klare Verantwortungs- und Änderungsgrenzen.
Die vier OOP-Grundprinzipien
- Kapselung: Zustand und Verhalten bündeln und nur kontrollierten Zugriff erlauben.
- Abstraktion: eine nützliche Schnittstelle zeigen und unnötige Implementierungsdetails verbergen.
- Vererbung: eine Klasse nur bei einer echten Ist-ein-Beziehung spezialisieren.
- Polymorphie: dieselbe Operation auf verschiedenen Objekttypen mit passendem Verhalten verwenden.
Aufbau des Beispiels
- BankAccount besitzt den Kontostand und validiert Einzahlungen.
- SavingsAccount übernimmt den Vertrag der Basisklasse.
- SavingsAccount überschreibt month_end für die Verzinsung.
- Die Schleife nutzt alle Konten über dieselbe Schnittstelle.
Wann verwendet man das?
- Mehrere Arten von Objekten, die das meiste Verhalten teilen: Kontoarten, Formen, Spielfiguren.
- Code, der später mit neuen Arten funktionieren muss, ohne umgeschrieben zu werden.
- Daten schützen, die gültig bleiben müssen, etwa ein Kontostand, der nie negativ sein darf.
Wann du es nicht brauchst
- Kleine Skripte mit ein paar Funktionen: Klassen und Vererbung bringen Struktur, die du nicht brauchst.
- Tiefe Vererbungsketten (A erbt von B, B von C, C von D): Sie sind schwer nachzuvollziehen. Setz lieber auf Komposition, also auf Objekte, die andere Objekte enthalten.
Einfaches Beispiel
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = float(balance)
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self._balance += amount
def month_end(self):
return "No interest"
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, interest_rate):
super().__init__(owner, balance)
self.interest_rate = interest_rate
def month_end(self):
self._balance *= 1 + self.interest_rate
return "Interest applied"
accounts = [
BankAccount("Ada", 100),
SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)
for account in accounts:
status = account.month_end()
print(f"{account.owner}: {account.balance:.2f} ({status})")
Ergebnis der Ausführung
Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)
Die vier OOP-Prinzipien in der Praxis
Diese gezielten Beispiele zeigen, wie Python Kapselung, Abstraktion, Vererbung und Polymorphie im alltäglichen Code umsetzt.
Kapselung
Zustand und Verhalten bündeln und nur kontrollierten Zugriff erlauben.
class BankAccount:
def __init__(self, balance=0):
# Double underscores prevent accidental direct access.
self.__balance = balance
@property
def balance(self):
# Expose read access without exposing mutation.
return self.__balance
def deposit(self, amount):
# Keep validation next to the state it protects.
if amount <= 0:
raise ValueError("Amount must be positive")
self.__balance += amount
account = BankAccount(100)
account.deposit(50)
print(account.balance) # 150
Abstraktion
eine nützliche Schnittstelle zeigen und unnötige Implementierungsdetails verbergen.
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
# Callers know what pay does, not how each provider does it.
pass
class CreditCard(PaymentMethod):
def pay(self, amount):
# The concrete class hides its payment implementation.
return f"Paid ${amount:.2f} by card"
payment = CreditCard()
print(payment.pay(25))
Vererbung
eine Klasse nur bei einer echten Ist-ein-Beziehung spezialisieren.
class Employee:
def __init__(self, name):
self.name = name
def describe(self):
return self.name
class Developer(Employee):
def __init__(self, name, language):
# Reuse initialization from the parent class.
super().__init__(name)
self.language = language
def describe(self):
# Extend inherited behavior instead of duplicating it.
return f"{super().describe()} writes {self.language}"
print(Developer("Ada", "Python").describe())
Polymorphie
dieselbe Operation auf verschiedenen Objekttypen mit passendem Verhalten verwenden.
class EmailNotification:
def send(self, message):
return f"Email: {message}"
class SmsNotification:
def send(self, message):
return f"SMS: {message}"
def notify(channels, message):
for channel in channels:
# The same call selects behavior from each concrete object.
print(channel.send(message))
channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")
Erklärung des Codes
Die Klasse BankAccount kapselt den Kontostand im Attribut _balance und erlaubt Änderungen nur über geprüfte Methoden wie deposit(). Die Klasse SavingsAccount erbt all diese Methoden und überschreibt month_end(), um Zinsen gutzuschreiben. Die Schleife ruft für beide Konten dieselbe Methode auf, Python wählt aber zur Laufzeit die passende Version für jeden Objekttyp. Genau das ist Polymorphie.
Ändere die Werte und führe das Programm im CodeUtility Python Online-Compiler aus, ohne Python lokal zu installieren.
Übungen zur Vertiefung
Ändere den Code anhand der folgenden Vorschläge. Wenn du selbst etwas änderst und das Ergebnis beobachtest, verstehst du viel mehr, als wenn du den Code nur liest.
- Ändere die Eingabedaten und sage das Ergebnis voraus, bevor du den Code ausführst.
- Füge eine Prüfung für leere oder ungültige Daten hinzu.
- Lagere die Logik in eine eigene Funktion aus und teste sie mit verschiedenen Datensätzen.
Häufige Fehler
super().__init__ nicht aufrufen
Ohne den Aufruf läuft die Einrichtung der Basisklasse nie, und Attribute wie owner fehlen.
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
self.interest_rate = rate
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
super().__init__(owner, balance)
self.interest_rate = rate
Geschützte Daten direkt ändern
Wer _balance von außen setzt, umgeht die Prüfungen in deposit().
account._balance = -500
account.deposit(50)
Lektion fertig?
Markiere sie als gelernt, um deinen Fortschritt zu verfolgen.
Mit einer Challenge üben
Nutze den Inhalt dieser Lektion, um ein echtes Problem zu lösen. Jede Challenge läuft im Browser, mit sofortigen Tests und einem KI-Review.
Alle Challenges