Wenn ein Skript wächst, übergeben Sie am Ende dieselbe Gruppe von Variablen zwischen Funktionen, und es wird schwierig zu sagen, welche Daten zu welcher Logik gehören. Python-Klassen und -Objekte lösen dieses Problem, indem sie Daten und Verhalten in einer Einheit bündeln.

In diesem Tutorial erstellen wir Schritt für Schritt ein kleines Bankkonto und fügen jede OOP-Idee nur dann hinzu, wenn sie ein Problem löst. Wir haben jedes Beispiel auf Python 3.13 ausgeführt und die angezeigte Ausgabe stammt von diesem Lauf. Wenn Sie neu in der Sprache sind, lesen Sie zuerst unser Python-Tutorial für Anfänger.

Was sind Klassen und Objekte?

Eine Klasse beschreibt, was etwas ist und was es tun kann. Ein Objekt, auch Instanz genannt, ist ein bestimmtes Objekt, das aus dieser Beschreibung erstellt wurde. „Konto“ ist eine Klasse, während Ashas Konto und Bens Konto zwei Objekte sind.

Sie haben die ganze Zeit über Objekte verwendet. In Python sind Strings, Listen und sogar Funktionen Objekte, weshalb Sie "hello".upper() schreiben können.

Deine erste Klasse

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ wird automatisch ausgeführt, wenn Sie ein Objekt erstellen, und legt den Startstatus fest. Die Einzahlung in a berührte b nicht, da jedes Objekt seine eigenen Daten hat. Beachten Sie, dass die Methode auch den Saldo vor einem schlechten Wert schützt. Unser Leitfaden zur Python-Ausnahmebehandlung erläutert raise ausführlicher.

Was ist Selbst?

self ist einfach das Objekt, an dem eine Methode arbeitet. Wenn Sie a.deposit(50) schreiben, ruft Python effektiv Account.deposit(a, 50) auf und übergibt das Objekt als erstes Argument. Auf diese Weise kann eine Methodendefinition jedes Objekt bedienen.

Der Name self ist eher eine starke Konvention als ein Schlüsselwort, aber verwenden Sie ihn immer. Das Vergessen in einer Methodendefinition ist der häufigste Anfängerfehler und führt zu einer verwirrenden Meldung über die Anzahl der Argumente.

Klassenattribute vs. Instanzattribute

Ein direkt im Klassenkörper festgelegtes Attribut wird von allen Objekten gemeinsam genutzt. Ein Satz auf self gehört nur zu diesem Objekt. Dieses Beispiel zeigt, wie sich Suchvorgänge verhalten:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Diese letzte Zeile überrascht die Leute. Die Zuweisung über a hat den gemeinsamen Wert nicht geändert. Es wurde ein neues Instanzattribut auf a erstellt, das das Klassenattribut verbirgt. Python betrachtet zuerst das Objekt und dann die Klasse.

Spezielle (Dunder-)Methoden

Methoden mit doppelten Unterstrichen ermöglichen es Ihren Objekten, mit den integrierten Funktionen von Python zu arbeiten. Ohne sie zeigt das Drucken eines Kontos eine nutzlose Speicheradresse an. Das Hinzufügen von zwei ergibt eine lesbare Form:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Vererbung

Durch Vererbung kann eine neue Klasse eine vorhandene Klasse wiederverwenden und nur die Unterschiede ändern. Hier ist Savings ein Account mit einer zusätzlichen Einstellung:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() ruft die Version des übergeordneten Elements auf, sodass die Setup-Logik nicht wiederholt wird. deposit wurde unverändert übernommen und __str__ wurde überschrieben, um eine Bezeichnung hinzuzufügen. Verwenden Sie die Vererbung nur für eine echte „ist ein“-Beziehung. Wenn eine Klasse lediglich etwas benötigt, beispielsweise ein Auto, das einen Motor benötigt, geben Sie ihr dieses Objekt als Attribut. Dies wird als Komposition bezeichnet und ist in der Regel flexibler als tiefe Vererbungsketten.

Polymorphismus

Polymorphismus bedeutet, dass verschiedene Objekte auf unterschiedliche Weise auf denselben Methodenaufruf reagieren können. Der Aufrufcode muss den genauen Typ nicht kennen:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Diese beiden Klassen haben nicht einmal ein gemeinsames übergeordnetes Element. Python kümmert sich nur darum, dass das Objekt eine area-Methode hat, ein Ansatz, der als Duck-Typing bekannt ist. Das spätere Hinzufügen von Triangle würde keine Änderung der Schleife erfordern.

Kapselung und Eigenschaften

Python hat keine wirklich privaten Attribute und verlässt sich stattdessen auf Konventionen. Ein einzelner Unterstrich, wie in _price, sagt anderen Entwicklern: „Dies ist intern, bitte nicht berühren“. Um Werte zu überprüfen, wenn sie festgelegt sind, verwenden Sie eine Eigenschaft, die von außen wie ein einfaches Attribut aussieht:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Das bedeutet, dass Sie mit einem einfachen Attribut beginnen und später eine Validierung hinzufügen können, ohne den Code zu ändern, der die Klasse verwendet. Schreiben Sie die Methoden get_price() und set_price() also nicht aus Gewohnheit, wie Sie es vielleicht in Java tun würden. Die @-Syntax hier ist ein Dekorator, den wir unter Python-Dekoratoren erklärt erläutern.

Klassenmethoden und statische Methoden

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Datenklassen

Wenn eine Klasse hauptsächlich Daten enthält, ist das manuelle Schreiben von __init__, __repr__ und __eq__ mühsam. @dataclass generiert sie aus Typanmerkungen:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Häufige Fehler

Verwendung eines veränderlichen Klassenattributs

Das ist ein klassischer Fehler. Die Liste ist für die Klasse definiert, sodass alle Warenkörbe sie gemeinsam nutzen:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Erstellen Sie es in __init__ mit self.items = [], sodass jedes Objekt eine eigene Liste erhält.

Andere häufige Fehler

• self vergessen. Schreiben Sie self.balance, nicht balance, in Methoden.
• Vergessen super().__init__(). Das Kind vermisst dann Attribute, die vom Elternteil eingerichtet wurden.
• Große Klassen erstellen. Eine Klasse, die alles kann, ist schwer zu testen. Teilen Sie es nach Verantwortung auf.
• Tiefe Vererbung. Zwei Ebenen reichen normalerweise aus und die Zusammensetzung ist oft klarer.
• Keine Tests schreiben. Klassen mit Regeln sind einfach zu testen, wie unser Pytest-Tutorial mit einem kleinen Wagen zeigt.

Fazit

Beim objektorientierten Python geht es darum, Daten mit dem Verhalten zu gruppieren, das sie schützt. Beginnen Sie mit __init__, Methoden und __str__ und fügen Sie dann Vererbung und Eigenschaften hinzu, wenn Sie auf ein Problem stoßen, das sie lösen. Nehmen Sie als nächsten Schritt ein Skript, das überall die gleichen wenigen Variablen übergibt, und wandeln Sie sie in eine kleine Klasse um.

Häufige Fragen

Lerne weiter