Python-Grundlagen

Objektorientierte Programmierung in Python

In dieser Lektion lernst du Kapselung, Vererbung, das Überschreiben von Methoden und Polymorphie an einem Bankkonto-Beispiel in Python kennen.

  • Einsteiger
  • 4 Min. Lesezeit
  • 1 ausführbares Beispiel

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).

Von der Bank zum Code
self._balance🔒 Das Geld hinter dem Schalter: nur über deposit() ändern
class SavingsAccount(BankAccount):🏦 Ein Sparkonto ist ein Konto mit Zinsen obendrauf
super().__init__(owner, balance)📋 Zuerst das normale Kontoformular ausfüllen
account.month_end()📅 Dieselbe Anfrage, jedes Konto antwortet auf seine Art
Gemeinsame Regeln in der Basisklasse, Unterschiede in der Unterklasse.
In einem Satz

Objektorientierte 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

  1. BankAccount besitzt den Kontostand und validiert Einzahlungen.
  2. SavingsAccount übernimmt den Vertrag der Basisklasse.
  3. SavingsAccount überschreibt month_end für die Verzinsung.
  4. Die Schleife nutzt alle Konten über dieselbe Schnittstelle.
Designtipp: Bevorzuge Komposition, wenn ein Objekt ein anderes nur verwendet. Nutze Vererbung nur, wenn das Kind die Elternklasse korrekt ersetzen kann.

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

Code ausführen →
main.py
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})")
Run-Button für dieses Beispiel erstellen

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

Code ausführen →

Zustand und Verhalten bündeln und nur kontrollierten Zugriff erlauben.

encapsulation.py
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

Code ausführen →

eine nützliche Schnittstelle zeigen und unnötige Implementierungsdetails verbergen.

abstraction.py
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

Code ausführen →

eine Klasse nur bei einer echten Ist-ein-Beziehung spezialisieren.

inheritance.py
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

Code ausführen →

dieselbe Operation auf verschiedenen Objekttypen mit passendem Verhalten verwenden.

polymorphism.py
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.

  1. Ändere die Eingabedaten und sage das Ergebnis voraus, bevor du den Code ausführst.
  2. Füge eine Prüfung für leere oder ungültige Daten hinzu.
  3. Lagere die Logik in eine eigene Funktion aus und teste sie mit verschiedenen Datensätzen.
Im Python-Compiler ausführen →

Häufige Fehler

super().__init__ nicht aufrufen

Ohne den Aufruf läuft die Einrichtung der Basisklasse nie, und Attribute wie owner fehlen.

Problem
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Lösung
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().

Problem
account._balance = -500
Lösung
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