Klassen in Python: objektorientierte Programmierung

Du hast bereits Objekte verwendet, wann immer du mit einer Zahl, Zeichenkette, Liste oder einem Wörterbuch gearbeitet hast. Ein Objekt hat einen Datentyp, einen Wert oder Zustand und Operationen, die es unterstützt. Sogar Funktionen und None sind Objekte. Mit einer eigenen Klasse erweiterst du dieses vertraute System.

Datentyp und Methoden eines Objekts finden

type("hello") gibt <class 'str'> zurück; type([1, 2]) gibt <class 'list'> zurück. Die Wörter Datentyp und Klasse beschreiben hier dieselbe Rolle. isinstance(3.5, float) ist True, während isinstance("3.5", float) gleich False ist: Der zweite Wert ist Text, auch wenn er wie eine Zahl aussieht.

Eine Methode ist eine Funktion, die ein Datentyp bereitstellt. In "ada lovelace".title() ist die Zeichenkette vor dem Punkt das Objekt, title die Methode und die Klammern rufen sie auf. Das Ergebnis ist "Ada Lovelace". dir(value) listet die Namen auf, die ein Objekt anbietet; Namen wie __len__ sind Spezialmethoden, die Objekte mit Python-Operationen wie len(value) verbinden.

Ergebnis und ursprüngliches Objekt verfolgen

Ein Methodenaufruf kann ein Ergebnis zurückgeben, ein Objekt verändern oder beides tun. Prüfe das Verhalten der Methode, bevor du entscheidest, was du zuweist.

word = "level"
print(word.count("l"))  # 2
print(word.upper())     # LEVEL
print(word)             # level

nums = [3, 1, 2]
result = nums.sort()
print(nums)             # [1, 2, 3]
print(result)           # None

Zeichenketten sind unveränderlich: Ihr Inhalt kann sich nicht ändern. upper() gibt eine andere Zeichenkette zurück, sodass word seinen ursprünglichen Wert behält. Um das großgeschriebene Ergebnis unter diesem Namen zu speichern, schreibe word = word.upper().

Listen sind veränderlich. sort() verändert die Liste direkt und gibt None zurück. Mit nums = nums.sort() geht die in nums gespeicherte Listenreferenz verloren und None wird zugewiesen. Verwende nums.sort() in einer eigenen Zeile oder nums = sorted(nums), um eine neue sortierte Liste zu erhalten. Bei einem Wörterbuch gibt {"a": 1}.get("b", 0) den Wert 0 zurück, weil der gesuchte Schlüssel fehlt.

Auch Klammern sind wichtig. word.upper ist ein Methodenobjekt; word.upper() führt es aus. Viele Objekte können dasselbe Verhalten anbieten: "cat".upper() und "dog".upper() verwenden dieselbe Art von Methode mit unterschiedlichen Zeichenkettendaten.

Gleichheit und Identität unterscheiden

Gleichheit fragt, ob Werte übereinstimmen. Identität fragt, ob sich zwei Namen auf ein Objekt beziehen.

a = [1, 2]
b = [1, 2]
c = a
print(a == b)  # True
print(a is b)  # False
print(c is a)  # True
c.append(3)
print(a)       # [1, 2, 3]
print(b)       # [1, 2]

a und b haben anfangs gleiche Inhalte, sind aber separate Listen. c = a erstellt einen Alias, einen weiteren Namen für dieselbe Liste. Das Anhängen über c verändert das Objekt, auf das sich auch a bezieht. Die separate Liste, auf die b verweist, ändert sich nicht. Zeichne beim Nachvollziehen eines Programms einen Kasten pro Objekt und einen Pfeil von jedem Namen zu seinem Kasten.

Eine Klasse definiert einen Datentyp, den du in deinem eigenen Programm verwenden kannst. Jedes daraus erstellte Objekt ist eine Instanz. Eine Klasse beschreibt die Art des Objekts; Instanzen enthalten die Daten einzelner Objekte. Ein leeres Formular und seine ausgefüllten Kopien sind ein hilfreicher Vergleich.

Eine Klasse schreiben und aufrufen

Eine class-Anweisung besteht aus dem Schlüsselwort class, einem Namen, einem Doppelpunkt und einem eingerückten Körper. pass stellt einen leeren Körper bereit, während du die Struktur ausprobierst.

class Book:
    pass

b1 = Book()
b2 = Book()
print(b1 is b2)           # False
print(isinstance(b1, Book))  # True

Jeder Aufruf von Book() erstellt eine separate Instanz. In einem Skript zeigt type(b1) den Wert <class '__main__.Book'>. Die class-Anweisung muss ausgeführt werden, bevor Code versucht, Book zu verwenden. Du kannst eine Klasse auch in einem Modul definieren, sie mit from library import Book importieren und dann im aufrufenden Programm Instanzen erstellen.

Beachte die Namenskonventionen von Python: Book, BankAccount und ShoppingCart verwenden CapWords, wobei jedes Wort mit einem Großbuchstaben beginnt. Variablen und Methoden verwenden kleingeschriebene Wörter, die durch Unterstriche getrennt sind, etwa book_count und add_item. Verwende für jede Einrückungsebene vier Leerzeichen.

Daten auf jeder Instanz speichern

Ein Attribut ist ein benannter Wert, auf den du mit einem Punkt zugreifst. Eine Zuweisung an ein Attribut speichert den Wert; durch Lesen desselben Namens rufst du ihn ab.

b1.title = "Dune"
b2.title = "Emma"
b1.pages = 412
print(b1.title)  # Dune
print(b2.title)  # Emma
print(b1.pages)  # 412

Die Daten gehören zur ausgewählten Instanz. Wenn du b1 ein Attribut pages gibst, erhält b2 keines. Das Lesen von b2.pages löst nun AttributeError aus, weil dieses Objekt kein Attribut namens pages hat.

Zuweisungen können neue Namen erstellen, ohne deine Absicht zu prüfen. Nach b1.titel = "X" enthält das ursprüngliche b1.title weiterhin "Dune"; das Objekt hat ein zweites Attribut mit einem falsch geschriebenen Namen erhalten. Wenn sich ein Wert scheinbar nicht ändert, vergleiche die Schreibweise bei der Zuweisung und beim Lesen.

Klasse und Instanzen unterscheiden

b = Book gibt der Klasse einen weiteren Namen. Es erstellt kein Buch. Wurden Titel nur auf Instanzen gesetzt, löst die Anfrage nach Book.title einen AttributeError aus; es gibt keinen einzelnen Titel, den alle Objekte dieses Datentyps teilen.

Jedem Objekt einen verlässlichen Anfang geben

Attribute von außen zu setzen ist möglich, verteilt die Einrichtung aber über das Programm. Ein Buch könnte einen Titel und eine Seitenzahl erhalten, ein anderes nur einen Titel. Späterer Code kann nicht sicher voraussetzen, dass beide pages haben.

Eine Einrichtungsmethode namens __init__ platziert die anfänglichen Zuweisungen innerhalb der Klasse. Jeder Aufruf zur Erstellung folgt dann demselben Einrichtungsprozess. Die Klasse kann einen Titel verlangen und andere Attribute mit sinnvollen Anfangswerten erstellen, sodass sich der aufrufende Code keine separate Folge von Zuweisungen merken muss.

Jedes neu erstellte Konto benötigt einen Inhaber und einen Anfangskontostand. Wenn diese Einrichtung in __init__ steht, erhält jedes Objekt die Attribute, die spätere Methoden erwarten. Python erstellt zuerst die Instanz und ruft dann __init__ auf, um sie zu initialisieren.

Argumente mit Attributen verbinden

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

acct = BankAccount("Maya", 50)
other = BankAccount("Leo")

Beim ersten Aufruf übergibt Python das neue Konto als self, "Maya" als owner und 50 als balance. Durch die Zuweisungen wird acct.owner gleich "Maya" und acct.balance gleich 50. Der zweite Aufruf verwendet den Standardwert für den Kontostand, sodass other.balance gleich 0 ist.

self ist der Parameter, der das aktuelle Objekt erhält. Es ist eine Konvention und kein Python-Schlüsselwort. Verwende diesen Namen, damit Lesende das Objekt sofort erkennen. Der aufrufende Code lässt ihn weg: BankAccount("Maya", 50) übergibt zwei Argumente, nicht drei.

Lokale Namen und gespeicherte Daten unterscheiden

In self.owner = owner ist der Name rechts ein lokaler Parameter. Der Name links ist ein Attribut, das auf dem Objekt gespeichert wird. Nach der Initialisierung können andere Methoden self.owner weiterhin verwenden.

balance = balance weist nur dem lokalen Namen erneut einen Wert zu. Es erstellt kein Attribut, sodass das spätere Lesen von acct.balance scheitert. Setze self. vor jedes Attribut, das Teil des Objekts bleiben soll.

Plane die Initialisierung, indem du auflistest, was jede Instanz benötigt. Erforderliche Werte werden zu Parametern nach self; optionale Werte können Standardwerte haben. Werte, die immer gleich beginnen, können im Körper zugewiesen werden, etwa self.visits = 0. Eine mit self.transactions = [] erstellte Liste wird bei jedem Aufruf neu angelegt.

Eine gemeinsam genutzte Standardliste vermeiden

Ein Standardargument wird ausgewertet, wenn Python die Methode definiert. Bei def __init__(self, items=[]) erhalten Aufrufe, die items weglassen, dieselbe Liste. Speichert der Initialisierer diese Liste direkt, ändert eine Änderung an den Elementen eines Objekts auch die Elemente, die ein anderes sieht.

Verwende None als Standardwert und erstelle bei jedem Aufruf eine neue Liste:

class Cart:
    def __init__(self, items=None):
        self.items = [] if items is None else list(items)

a = Cart()
b = Cart()
a.items.append("pen")
print(b.items)  # []

list(items) erstellt auch dann eine neue äußere Liste, wenn der aufrufende Code eine Liste übergibt. Die Objekte in dieser Liste werden weiterhin über gemeinsame Referenzen genutzt; beim Erstellen der Liste wird nicht jedes Element neu erstellt.

Fehler bei der Einrichtung lesen

BankAccount() fehlt das erforderliche Argument owner und löst TypeError aus. Vergleiche den Aufruf mit den Parametern nach self.

Die Schreibweise __init__ hat auf jeder Seite zwei Unterstriche. _init_ ist ein gewöhnlicher Methodenname und führt diese Einrichtung nicht automatisch aus. __init__ muss None zurückgeben, also lass normalerweise eine return-Anweisung weg. Die Rückgabe eines Kontostands löst TypeError aus; der Klassenaufruf selbst liefert dem aufrufenden Code die neue Instanz.

Einige Werte beschreiben ein einzelnes Objekt, andere den Datentyp als Ganzes. Die Größe einer Pizza gehört zu dieser Pizza. Eine Obergrenze für Beläge oder ein Zähler für erstellte Pizzen kann zur Klasse gehören. Wo eine Zuweisung erfolgt, bestimmt, welche Art von Attribut sie erstellt.

Den Wert an der richtigen Stelle ablegen

class Pizza:
    MAX_TOPPINGS = 5
    count = 0

    def __init__(self, size):
        self.size = size
        self.toppings = []
        Pizza.count += 1

p1 = Pizza("large")
p2 = Pizza("small")

size und toppings sind Instanzattribute, die auf self gesetzt werden. Jede Pizza hat ihre eigenen Werte. MAX_TOPPINGS und count sind Klassenattribute, die im Klassenkörper außerhalb einer Methode zugewiesen werden. Großbuchstaben kennzeichnen einen Wert, der als Konstante gedacht ist; sie verhindern keine erneute Zuweisung.

Nach diesen Aufrufen ist Pizza.count gleich 2. Jeder Initialisierer aktualisiert dasselbe Klassenattribut. p1.size ist "large", während p2.size gleich "small" ist.

Attributsuche und Verdeckung nachvollziehen

Beim Lesen von p1.MAX_TOPPINGS wird bei gewöhnlichen Datenattributen wie diesen zuerst die Instanz und dann die Klasse geprüft. Da auf p1 kein Wert gespeichert ist, findet Python Pizza.MAX_TOPPINGS, also 5.

Eine Zuweisung über eine Instanz wirkt anders:

p1.MAX_TOPPINGS = 8
Pizza.MAX_TOPPINGS = 6
print(p1.MAX_TOPPINGS)     # 8
print(p2.MAX_TOPPINGS)     # 6
print(Pizza.MAX_TOPPINGS)  # 6

Die erste Zeile erstellt ein Instanzattribut auf p1. Es verdeckt den Klassenwert für dieses Objekt. Eine spätere Änderung des Klassenwerts erreicht p2, das den Wert weiterhin von der Klasse liest, ersetzt aber nicht den eigenen Wert von p1.

Auf zwei Arten unbeabsichtigter gemeinsamer Nutzung achten

Würde der Initialisierer self.count += 1 verwenden, würde Python die 0 der Klasse lesen, eins addieren und ein Instanzattribut speichern. Jede neue Pizza würde einen eigenen Wert 1 für count erhalten, während Pizza.count bei 0 bliebe. Nenne die Klasse, wenn du einen klassenweiten Zähler aktualisierst.

Eine Liste im Klassenkörper verursacht ein anderes Problem. Bei toppings = [] finden alle Instanzen ohne separates Belagattribut dieselbe Liste. p1.toppings.append("olives") verändert diese gemeinsam genutzte Liste; es weist kein neues Instanzattribut zu. Setze self.toppings = [] in __init__, wenn jede Pizza ihren eigenen Belag benötigt.

Eigene Daten eines Objekts untersuchen

Für das ursprüngliche p2 ergibt vars(p2) den Wert {'size': 'small', 'toppings': []}. Die Klassenwerte fehlen, weil sie auf Pizza liegen. Das ist bei der Fehlersuche nach einer überraschenden Attributsuche nützlich: Prüfe, ob die Instanz einen eigenen Wert hat, und untersuche dann den Klassenwert. Eine gemeinsame Einstellung gehört auf die Klasse; ein Name, eine Größe, ein Kontostand oder eine persönliche Sammlung gehört auf die Instanz.

Ein Objekt sollte in einem Zustand beginnen, den seine Methoden verwenden können. Ein Rechteck mit negativer Breite kann die beabsichtigte Form nicht darstellen. Eine Regel, die für jedes Objekt einer Klasse immer gelten muss, heißt Invariante. Die Validierung prüft diese Regeln, bevor Daten übernommen werden.

Vor dem Speichern prüfen

class Rectangle:
    def __init__(self, width, height):
        if width <= 0:
            raise ValueError("width must be positive")
        if height <= 0:
            raise ValueError("height must be positive")
        self.width = width
        self.height = height

Rectangle(3, 4) besteht beide Prüfungen und gibt ein initialisiertes Objekt zurück. Rectangle(-2, 4) löst bei der ersten Prüfung ValueError aus. Die späteren Zuweisungen werden nicht ausgeführt. Fängt das Programm diese Ausnahme nicht ab, stoppt die Ausführung an dieser Stelle.

Angenommen, r verweist bereits auf ein gültiges Rechteck. Bei r = Rectangle(-2, 4) scheitert der Aufruf rechts vor der Zuweisung. r behält seinen vorherigen Wert. Hatte r vor dem fehlgeschlagenen Aufruf keinen Wert, erstellt die Zuweisung auch keinen.

Eine hilfreiche Ausnahme wählen

Eine negative Breite als Zahl ist ein Wertfehler. Text, der anstelle einer benötigten Zahl übergeben wird, ist ein Typfehler. Der Vergleich mit 0 löst in diesem Beispiel bei Text bereits TypeError aus. Eine Klasse kann einen Datentyp auch ausdrücklich mit isinstance prüfen, wenn sie eine klarere Meldung benötigt.

Schreibe Meldungen, die die Regel nennen, etwa "width must be positive". Bei einer Meldung, die nur "bad input" sagt, müssen die Aufrufenden raten, welcher Wert korrigiert werden muss.

Fehlerbehandlung dem aufrufenden Code überlassen

while True:
    try:
        width = float(input("Width: "))
        room = Rectangle(width, 3)
        break
    except ValueError as error:
        print("Try again:", error)

Die Eingabe abc scheitert bei float; die Eingabe -2 besteht die Umwandlung, scheitert aber in Rectangle. Beide lösen ValueError aus, sodass diese Schleife beide Fälle behandelt. Die Klasse gibt ihre Datenregel vor, während der aufrufende Code entscheidet, erneut zu fragen.

Eine Warnung innerhalb von __init__ auszugeben weist den Aufruf nicht zurück. Wird die Ausführung fortgesetzt, kann das Programm ein ungültiges Objekt erhalten und später bei dessen Verwendung scheitern. Das Auslösen einer Ausnahme stoppt die fehlgeschlagene Einrichtung dort, wo das Problem auftritt.

Daten gezielt bereinigen und die Regel einhalten

Eine dokumentierte Bereinigung kann nützlich sein. self.name = name.strip() entfernt Leerzeichen am Rand; validiere den bereinigten Namen, wenn leere Namen verboten sind. self.items = list(items) erstellt eine separate äußere Liste, sodass das Anhängen an die Liste des aufrufenden Codes nichts an diese Liste anhängt. Eine ungültige Breite in ihren Betrag zu ändern, würde die Absicht des aufrufenden Codes ändern und benötigt daher eine ausdrückliche Entwurfsregel.

Die Prüfungen bei der Initialisierung laufen zum Zeitpunkt der Erstellung. Eine einfache Zuweisung wie r.width = -5 umgeht sie später trotzdem. Methoden, die eine Breite ändern, müssen sie erneut prüfen. Eine Property kann eine Prüfung direkt bei der Attributzuweisung vornehmen, sodass dieselbe Regel bei der Einrichtung und bei späteren Aktualisierungen ausgeführt wird.

Eine Instanzmethode ist eine innerhalb einer Klasse definierte Funktion, die mit dem als self übergebenen Objekt arbeitet. Das Objekt liefert seine gespeicherten Daten; zusätzliche Parameter liefern weitere Informationen, die für die Aktion benötigt werden.

Attribute über self lesen

Füge diese Methoden innerhalb der validierten Klasse Rectangle auf derselben Einrückungsebene wie __init__ hinzu:

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

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

    def is_square(self):
        return self.width == self.height

Bei r = Rectangle(3, 4) gibt r.area() den Wert 12, r.perimeter() den Wert 14 und r.is_square() den Wert False zurück. Jede Methode liest die Attribute desselben Objekts. Ein zweites Rechteck verwendet dieselben Methodendefinitionen mit seiner eigenen Breite und Höhe.

Innerhalb einer Methode bezeichnet self.width ein Attribut. Ein alleinstehendes width bezeichnet eine lokale oder eine andere zugängliche Variable; Python sucht dafür nicht automatisch auf dem aktuellen Objekt. Existiert keine solche Variable, löst return width * height einen NameError aus. Mit self. machst du ausdrücklich kenntlich, zu welchem Objekt die Daten gehören.

Den Aufruf verfolgen

Für diese Klasse funktioniert r.area() wie Rectangle.area(r). Python findet die Funktion auf der Klasse und übergibt r als erstes Argument. Eine Methodenreferenz wie r.area ist eine gebundene Methode: Sie merkt sich die Funktion und dieses Rechteck. Mit () führst du den Aufruf aus.

Ist eine Methode als def resize(self, factor) definiert, rufe sie als r.resize(2) auf. r belegt self und 2 belegt factor. Du übergibst r nicht noch einmal. Wird eine Instanzmethode versehentlich als def area(): geschrieben, löst ein Aufruf auf r einen TypeError aus, weil Python das Objekt trotzdem an eine Funktion übergibt, die keine Argumente annimmt.

Eine Methode kann über self eine andere verwenden:

    def double_area(self):
        return self.area() * 2

Hier berechnet self.area() die Fläche desselben Rechtecks. Ohne self. würde eine separate Funktion namens area gesucht, nicht die Methode des Objekts.

Ergebnisse an den aufrufenden Code zurückgeben

Eine Berechnungsmethode sollte normalerweise ihr Ergebnis zurückgeben. Die Rückgabe liefert dem aufrufenden Code einen Wert zum Speichern, Kombinieren, Prüfen oder Anzeigen:

r1 = Rectangle(3, 4)
r2 = Rectangle(2, 5)
total = r1.area() + r2.area()
print(total)  # 22

Würde area seine Antwort nur ausgeben, gäbe jeder Aufruf None zurück. Die Addition würde dann mit TypeError scheitern, obwohl zwei Zahlen auf dem Bildschirm erschienen wären. Eine Ausgabe ist eine Aktion; eine Rückgabe liefert einen Wert an den Ausdruck, der den Aufruf enthält.

Verwende Methodennamen, die die Aufgabe zeigen. deposit und resize benennen Aktionen; is_square und has_room deuten auf boolesche Prüfungen hin. Für Daten, die bereits auf ihrem Objekt gespeichert sind, benötigt eine Methode keine Parameter. Für neue Eingaben, etwa einen Faktor zur Größenänderung oder einen Einzahlungsbetrag, benötigt sie Parameter.

Der Zustand eines Objekts besteht aus den aktuellen Werten seiner Attribute. Eine Zugriffsmethode gibt Auskunft über diesen Zustand. Eine Änderungsmethode verändert ihn. Eine nützliche Änderungsmethode prüft ihre Eingaben und hält alle zusammengehörenden Attribute aktuell, sodass der aufrufende Code nicht mehrere Aktualisierungen koordinieren muss.

Zuerst die gesamte Änderung validieren

Füge diese Methoden in die Klasse BankAccount mit ihrem Inhaber, Kontostand und ihrer Transaktionsliste ein:

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

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount
        self.transactions.append(("withdraw", amount))

Eine Einzahlung ändert den Kontostand und erfasst den Vorgang. Eine Auszahlung prüft vor dem Abziehen sowohl das Vorzeichen des Betrags als auch den verfügbaren Kontostand. Diese Prüfungen verhindern, dass eine abgelehnte Auszahlung den Kontostand oder dessen Verlauf ändert.

Ausgehend von BankAccount("Maya", 50) ergibt eine Einzahlung von 25 den Wert 75 und eine Auszahlung von 30 den Wert 45. Ein späterer Versuch, 100 abzuheben, löst ValueError aus; er belässt den Kontostand bei 45 und fügt keine Transaktion hinzu. Stünde die Subtraktion vor der Deckungsprüfung, würde sich der Zustand auch bei einem Fehlschlag ändern.

Eine Änderung von einem Rückgabewert unterscheiden

Diese Änderungsmethoden haben keine return-Anweisung und geben daher None zurück. Nach new_balance = acct.deposit(25) ist die Einzahlung erfolgt, aber new_balance ist None. Lies danach acct.balance, um den aktualisierten Wert zu erhalten.

Eine Klasse kann auch eine andere Art von Methode anbieten, die ein neues Objekt zurückgibt. resize deutet darauf hin, ein Rechteck zu verändern; resized kann für eine Methode gewählt werden, die ein neues Rechteck zurückgibt und das ursprüngliche unverändert lässt. Lies die Vereinbarung der Methode: Der Name hilft, aber ihre Definition bestimmt das Verhalten.

Gemeinsame Referenzen nachvollziehen

a = BankAccount("Maya", 50)
b = a
b.deposit(10)
print(a.balance)  # 60
print(a is b)     # True

Eine Zuweisung bindet einen Namen an ein Objekt; sie kopiert das Objekt nicht. Beide Namen führen zu dem Konto, dessen Kontostand sich geändert hat. Wird a an eine Funktion übergeben, erhält auch diese Zugriff auf das Objekt. Eine Funktion, die account.withdraw(5) aufruft, kann daher das Konto verändern, das der aufrufende Code sieht.

Für ein unabhängiges Konto mit demselben Inhaber und Kontostand erstelle BankAccount(a.owner, a.balance). Dieser Konstruktor liefert auch einen neuen, leeren Verlauf. Es ist ein neues Konto, keine vollständige Kopie des bisherigen Verlaufs.

copy.copy(a) erstellt ein neues äußeres Objekt, behält aber Referenzen auf dieselben inneren Objekte, einschließlich der Transaktionsliste. copy.deepcopy(a) kopiert auch verschachtelte Objekte. Wenn Unabhängigkeit wichtig ist, prüfe sowohl die Objekte innerhalb der Attribute als auch die äußere Instanz.

Eine direkte Zuweisung wie acct.balance = -500 umgeht die Prüfungen in den beiden Methoden. Konventionen für interne Attribute und Properties helfen, den vorgesehenen Weg für Aktualisierungen deutlich zu machen und die Validierung nahe an den Zustandsänderungen zu halten.

Der aufrufende Code benötigt eine klare Möglichkeit, ein Objekt zu lesen und zu verändern. Kapselung hält die Datenregeln eines Objekts bei den Methoden, die sie verwalten. Python verwendet Konventionen und Properties, um diese Schnittstelle auszudrücken.

Interne Speicherung kennzeichnen

Ein führender Unterstrich in _balance kennzeichnet ein internes Attribut. Der aufrufende Code sollte die Methoden des Kontos verwenden, aber Python erlaubt weiterhin den direkten Zugriff. Es gibt kein Schlüsselwort private, das den Wert wegsperrt.

Ein Name wie __balance mit zwei führenden und ohne zwei abschließende Unterstriche löst die Namensumformung aus. Innerhalb von class Acc wird self.__balance unter _Acc__balance gespeichert. Außerhalb scheitert obj.__balance, aber obj._Acc__balance kann weiterhin funktionieren. Die Namensumformung verhindert Namenskonflikte; sie schützt keine vertraulichen Daten.

Eine Methode über Attributsyntax ausführen

Eine Property führt eine Methode aus, wenn ein Attribut gelesen wird. Die Zeile @property ist ein Dekorator: Sie ändert, wie Python die Methode bereitstellt. Eine Property ohne Setter erlaubt das Lesen, weist aber Zuweisungen zurück.

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

    @property
    def balance(self):
        return self._balance

Lies nach acct = Account("Maya", 50) den Wert von acct.balance ohne Klammern. Die Zuweisung acct.balance = 10 löst AttributeError aus, weil diese Property keinen Setter hat. Eine Einzahlungsmethode innerhalb der Klasse könnte _balance nach ihren Prüfungen aktualisieren.

Zuweisungen mit einem Setter prüfen

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not 0 <= value <= 100:
            raise ValueError("score must be between 0 and 100")
        self._score = value

Getter und Setter haben denselben Namen score; der gespeicherte Wert verwendet _score. Bei der Erstellung führt self.score = score den Setter aus.

Bei s = Student("Ana", 88) speichert die Zuweisung s.score = 92 den Wert 92. Die Zuweisung s.score = -1 löst vor dem Speichern ValueError aus, sodass die Punktzahl bei 92 bleibt. Student("Ana", 105) scheitert bei der Initialisierung.

Innerhalb des Setters würde self.score = value den Setter erneut aufrufen. Das würde sich bis zum RecursionError wiederholen. Beim Getter besteht dasselbe Risiko, wenn er self.score zurückgibt. Verwende in beiden Körpern den separaten Speichernamen _score.

Werte beim Lesen berechnen

Eine Property kann einen Wert aus anderen Attributen berechnen:

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

Innerhalb einer Rechteckklasse ermöglicht dies r.area. Bei Breite 3 und Höhe 4 ist der Wert 12. Änderst du die Breite auf 5, gibt das nächste Lesen 20 zurück. Würde eine Fläche bei der Initialisierung einmal gespeichert, bliebe nach einer Änderung der Breite ein alter Wert zurück.

Beginne mit einem einfachen Attribut, wenn eine einfache Speicherung den Bedarf erfüllt.

Ein Objekt lässt sich leichter untersuchen, wenn es seine eigenen Daten beschreiben kann. Spezialmethoden ermöglichen Python, diese Beschreibung über vertraute Aktionen wie print, str und repr anzufordern. Ihre Namen beginnen und enden mit zwei Unterstrichen und werden oft Dunder-Namen genannt.

Text für zwei Zielgruppen wählen

__str__ liefert lesbaren Text für die Benutzer eines Programms. __repr__ liefert eine genaue Beschreibung für Programmierende. Beide geben Zeichenketten zurück; keine der beiden Methoden sollte ihr Ergebnis anstelle der Rückgabe ausgeben.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)        # (3, 4)
print(repr(p))  # Point(3, 4)

str(p) gibt die Zeichenkette "(3, 4)" zurück. repr(p) gibt "Point(3, 4)" zurück. Wenn möglich, ähnelt eine Darstellung einem Klassenaufruf, der den Wert erneut erstellen würde. Sie bleibt dennoch Text: Der Aufruf von repr selbst erstellt keinen weiteren Punkt.

Ohne eigene Darstellung zeigt eine einfache Instanz typischerweise einen Klassennamen und eine adressähnliche Kennung. Das hilft, Objekte zu unterscheiden, zeigt aber nicht ihre nützlichen Daten. Du rufst diese Spezialmethoden selten direkt auf; definiere sie einmal und verwende die üblichen Ausgabeoperationen von Python.

Vorhersagen, was ein Container anzeigt

Mit der obigen Klasse zeigt print([Point(3, 4), Point(0, 0)]) die Ausgabe [Point(3, 4), Point(0, 0)]. Die Liste verwendet die Darstellungen ihrer Elemente, obwohl jedes Element auch __str__ hat.

Definierst du nur __repr__, verwendet das standardmäßige __str__ diese Methode ebenfalls. Die alleinige Definition von __str__ ändert weder repr noch die Darstellung in Containern. Wenn du nur eine Darstellungsmethode hinzufügst, ist __repr__ daher in mehr Untersuchungssituationen hilfreich.

Zeichenkettenfelder eindeutig machen

Für ein Buch, das bereits title, author und year speichert, liefern diese Methoden unterschiedliche nützliche Ansichten:

    def __str__(self):
        return f"{self.title} by {self.author} ({self.year})"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r}, {self.year})"

Für das Buch mit dem Titel "Dune", dem Autor "Frank Herbert" und dem Jahr 1965 ergibt die erste Methode "Dune by Frank Herbert (1965)". Die zweite ergibt "Book('Dune', 'Frank Herbert', 1965)". !r fordert die Darstellungen der Zeichenkettenfelder einschließlich Anführungszeichen an.

Ein Körper, der nur print(self.x) enthält, gibt None zurück, sodass str(p) mit TypeError scheitert. Auch die Rückgabe einer ganzen Zahl scheitert. Erstelle den benötigten Text und gib dann diese Zeichenkette zurück.

Spezialmethoden verbinden eine Klasse mit Operatoren und eingebauten Funktionen. Definiere nur Operationen, deren Bedeutung für den jeweiligen Datentyp klar ist: Das Addieren von Vektoren ist verständlich; einen Spieler zu einem Team hinzuzufügen ist mit team.add_player(player) klarer.

Werte vergleichen und Hashwerte sicher halten

Zwei separate einfache Instanzen gelten standardmäßig als ungleich. Ergänze eine Punktklasse um Wertgleichheit:

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Nun gelten zwei Punkte bei (3, 4) als gleich, obwohl sich ihre Identitäten unterscheiden. in, count, index und remove können bei Listen solche gleichen Werte finden. Das übliche Ergebnis von != folgt aus __eq__.

NotImplemented ist ein Rückgabewert, der Python den anderen Operanden oder eine Ersatzlösung versuchen lässt. Es ist keine Ausnahme, die ausgelöst wird. Unterstützt keiner der Operanden Wertgleichheit, greift == auf die Identität zurück; ein Punkt und die Zeichenkette "3,4" gelten als ungleich.

Wird __eq__ ohne __hash__ definiert, sind die Instanzen nicht hashbar. Sie können dann weder Elemente einer Menge noch Schlüssel eines Wörterbuchs sein. Gleiche Objekte müssen gleiche Hashwerte haben und der Hashwert eines Schlüssels muss stabil bleiben. Wenn sich die verglichenen Attribute nie ändern, kann eine passende Hashmethode hash((self.x, self.y)) zurückgeben. Lass veränderliche Wertobjekte nicht hashbar, wenn sich ihre Gleichheitsfelder ändern können.

Eine Ordnung definieren

__lt__ stellt < bereit. Eine Klasse für Studierende kann Punktzahlen mit return self.score < other.score vergleichen. Die Punktzahlen 88, 72 und 95 werden dann zu 72, 88, 95 sortiert. min wählt die niedrigste; max wählt die höchste, indem es > und dessen reflektierten <-Vergleich verwendet.

Ist nur __lt__ definiert, kann a > b den Vergleich b < a verwenden. Python leitet <= oder >= nicht aus dieser Definition ab; sie benötigen eigene Methoden. Ist eine Ordnung nur für eine Aufgabe nützlich, übergib stattdessen eine Schlüsselfunktion:

def by_score(student):
    return student.score

ordered = sorted(students, key=by_score)

Neue Ergebnisse aus Rechnungen zurückgeben

Innerhalb einer Vektorklasse mit den Attributen x und y:

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Vector(self.x * factor, self.y * factor)

    def __rmul__(self, factor):
        return self * factor

Vector(1, 2) + Vector(3, 4) erzeugt einen neuen Vektor (4, 6). Die Multiplikation des ersten Vektors mit 3 erzeugt (3, 6) und lässt ihn unverändert. __mul__ behandelt den Vektor auf der linken Seite; __rmul__ unterstützt eine Zahl auf der linken Seite. Python nimmt nicht an, dass beide Reihenfolgen dasselbe bedeuten.

Eine sinnvolle Länge bereitstellen

Definiere für eine Wiedergabeliste, die self.songs speichert, __len__ so, dass es len(self.songs) zurückgibt. Das Ergebnis muss eine nicht negative ganze Zahl sein. len(playlist) zählt dann die Lieder. In dieser Klasse führt die Länge null auch dazu, dass if playlist: als falsch ausgewertet wird; ein eigenes __bool__ hätte bei der Wahrheitswertauswertung Vorrang vor der Länge.

Die Attribute eines Objekts können auf andere Objekte verweisen. Ein Einkaufswagen enthält Artikel, eine Bibliothek enthält Bücher und ein Kurs hat Teilnehmende. Komposition baut über diese Hat-ein-Beziehung ein größeres Objekt aus kleineren auf.

Jedem Objekt seine eigene Verantwortung geben

class Item:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        return self.price * self.quantity

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        if not isinstance(item, Item):
            raise TypeError("a cart holds Item objects")
        self.items.append(item)

    def total(self):
        total = 0
        for item in self.items:
            total += item.subtotal()
        return total

Der Einkaufswagen besitzt eine separate Liste, die bei der Initialisierung erstellt wird. Seine Methode add prüft das übergebene Objekt, bevor sie es anhängt. cart.add("pen") löst TypeError aus, statt Text zu speichern, der bei der Abfrage einer Zwischensumme zu einem Fehler führt.

Erstelle die Artikel vor oder während der Aufrufe:

cart = ShoppingCart()
cart.add(Item("notebook", 2.50, 4))
cart.add(Item("pen", 1.25, 3))
print(cart.total())         # 13.75
print(cart.items[0].name)   # notebook

Die Zwischensummen sind 10.0 und 3.75; der Einkaufswagen addiert sie zu 13.75. Die Kette cart.items[0].name greift zuerst auf die Liste des Einkaufswagens zu, dann auf deren erstes Objekt und schließlich auf den Namen dieses Objekts.

Arbeit an das zuständige Objekt delegieren

Der Einkaufswagen fragt jeden Artikel nach subtotal(). Das ist Delegation: Ein Objekt ruft für einen Teil einer Aufgabe die Methode eines anderen Objekts auf. Ändert ein Mengenrabatt die Berechnung einer Zwischensumme, gehört diese Regel in Item.subtotal. Der Einkaufswagen kann die zurückgegebenen Zwischensummen weiterhin addieren, ohne Preisregeln zu wiederholen.

Wer Item statt Item(...) übergibt, übergibt die Klasse und keinen gekauften Artikel. Die Typprüfung weist dieses Klassenobjekt zurück. Füge Artikel nur auf dem geprüften Weg hinzu; ein direkter Zugriff über cart.items.append(...) würde add umgehen.

Ein Objekt suchen

Füge diese Methode innerhalb von ShoppingCart hinzu:

    def find(self, name):
        for item in self.items:
            if item.name == name:
                return item
        return None

Beim ersten Treffer wird der vorhandene Artikel zurückgegeben. Gibt es keinen Treffer, wird None zurückgegeben. Prüfe found is None, bevor du found.name verwendest; None hat kein solches Attribut. Eine Methode __len__, die len(self.items) zurückgibt, könnte außerdem dafür sorgen, dass len(cart) die gespeicherten Artikelobjekte zählt, während __str__ Artikelzeilen zu einem Beleg zusammenfügen könnte.

Referenzen innerhalb von Sammlungen verfolgen

Eine Liste speichert Referenzen. Deshalb wird derselbe Artikel nicht kopiert, wenn er in zwei Einkaufswagen gelegt wird. Eine Änderung des Preises dieses Artikels wirkt sich auf die nächste Gesamtsumme beider Einkaufswagen aus. Separate Einkaufswagenlisten verhindern, dass versehentlich eine Liste gemeinsam genutzt wird, machen aber die enthaltenen Objekte nicht unabhängig. Erstelle separate Artikel, wenn die Einkaufswagen unabhängige Daten enthalten müssen.

Objekte können genau wie Zahlen oder Zeichenketten Methodenargumente und Rückgabewerte sein. Verfolge Empfängerobjekt, Argumente und Ergebnis getrennt: Eine Methode kann ein vorhandenes Objekt verändern, ein neues Objekt zurückgeben oder einfach einen Wert mitteilen.

Ein anderes Objekt als Eingabe verwenden

Innerhalb einer Punktklasse mit x und y kann eine Methode beide Punkte lesen:

    def midpoint(self, other):
        return Point((self.x + other.x) / 2,
                     (self.y + other.y) / 2)

Für p = Point(3, 4) und q = Point(1, 0) erstellt middle = p.midpoint(q) einen dritten Punkt bei (2.0, 2.0). Während des Aufrufs verweist self auf p und other auf q. Die Methode berechnet Koordinaten und erstellt einen neuen Punkt; sie weist keinem der ursprünglichen Punkte etwas zu.

Mit import math kann eine Abstandsmethode math.hypot(self.x - other.x, self.y - other.y) zurückgeben. Point(0, 0).distance_to(Point(3, 4)) ergibt dann 5.0. Dieser Aufruf gibt eine Zahl zurück, während midpoint ein Objekt zurückgibt.

Jedes Empfängerobjekt seine Änderungen verwalten lassen

Innerhalb einer Kontoklasse mit geprüften Methoden withdraw und deposit:

    def transfer_to(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

Hat Maya 100 und Leo 20, hebt maya.transfer_to(leo, 30) zuerst von Mayas Konto ab, sodass 70 bleiben. Dann wird auf Leos Konto eingezahlt, sodass dort 50 stehen. Beim ersten Aufruf ist self Mayas Konto. Beim Einzahlungsaufruf ist dessen eigenes self Leos Konto.

Eine spätere Überweisung von 500 scheitert in withdraw, weil Maya nur 70 hat. Die Ausführung stoppt vor deposit, sodass beide Kontostände ihre bisherigen Werte behalten. Die Reihenfolge der Aufrufe ist wichtig. Python macht eine frühere Zustandsänderung nicht rückgängig, wenn ein späterer Aufruf eine Ausnahme auslöst; diese kurze Methode setzt voraus, dass das Empfängerkonto den Betrag annehmen kann.

Der Aufruf other.deposit(amount) führt die Regeln des Empfängerkontos an einer Stelle aus. Eine direkte Änderung von other.balance würde sie umgehen.

Objekte verfolgen, nicht nur Variablennamen

Zeichne jede Instanz als Kasten mit ihren Attributen. Zeichne von jeder Variablen einen Pfeil zu ihrem Kasten. Bestimme bei einem Aufruf, welcher Kasten als self übergeben wird und welche Kästen als Argumente übergeben werden. Aktualisiere den betroffenen Kasten nach jeder erfolgreichen Zeile, die den Zustand ändert. Zwei Pfeile zu einem Kasten bedeuten, dass eine Änderung über einen der Namen dasselbe Objekt erreicht.

Auch eine einfache Funktion kann über mehrere Objekte hinweg arbeiten. total_balance(accounts) kann Konten durchlaufen und ihre Kontostände addieren. Diese Berechnung über die gesamte Liste muss nicht zu einem einzelnen Konto gehören.

Eine fehlende Beziehung darstellen

Ein Buch kann mit self.borrower = None beginnen und später ein Mitgliedsobjekt speichern. Prüfe die Beziehung, bevor du ein Attribut des Mitglieds liest:

if book.borrower is not None:
    print(book.borrower.name)

Andernfalls scheitert book.borrower.name, wenn das Buch keinen Entleiher hat. Klassen können oberhalb einer Funktion main() definiert werden, die die Objekte erstellt und verbindet. Wird main() unter if __name__ == "__main__": aufgerufen, werden diese Aktionen beim Importieren der Klassen nicht ausgeführt.

Eine Klasse ist sinnvoll, wenn zusammengehörende Daten und wiederholte Operationen gemeinsam leichter zu verstehen sind. Du musst nicht jede Funktion und jeden Datensatz in eine Klasse umwandeln. Wähle die Struktur, die die Verantwortlichkeiten des Programms deutlich macht.

Zusammengehörende Daten und Verhalten erkennen

Klassen helfen, wenn mehrere Funktionen immer wieder dieselbe Gruppe von Werten entgegennehmen, viele Datensätze dieselbe Struktur haben und Zustandsänderungen gemeinsamen Regeln folgen müssen. Mehrere Konten, die alle Ein- und Auszahlungen unterstützen, passen gut dazu. Eine einzelne Berechnung kann eine Funktion bleiben. Ein fester, schreibgeschützter Datensatz kann ein Tupel oder Wörterbuch bleiben.

Eine Klasse, die nur eine Einrichtung und eine einmalige Operation enthält, schafft oft mehr Aufwand als nützliche Struktur. Frag dich, was eine Instanz darstellt und welche wiederholten Aktionen zu ihr gehören. Kannst du diese Fragen nicht einfach beantworten, überdenke den Entwurf.

Eine Operation zu ihren Daten verschieben

Ein Konto auf Wörterbuchbasis könnte so beginnen:

account = {"owner": "Maya", "balance": 50}

def deposit(account, amount):
    account["balance"] += amount

Die Klassenversion kann dieselbe Operation neben ihrem Zustand und ihren Regeln platzieren:

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

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

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

Nach acct = BankAccount("Maya", 50) und acct.deposit(25) ist seine Darstellung BankAccount('Maya', 75). Die Regel für positive Einzahlungen wird nun jedes Mal ausgeführt, wenn der aufrufende Code diese Methode verwendet. Das Lesen von account["balence"] würde KeyError auslösen; das Lesen von acct.balence löst AttributeError aus. Eine Klasse beseitigt keine Schreibfehler, gibt den Daten und ihren Operationen aber einen benannten Platz.

Anhand einer kurzen Beschreibung planen

Bei „Eine Bibliothek verleiht Bücher an Mitglieder. Ein Mitglied kann höchstens 3 Bücher ausleihen“ deuten die Substantive auf Book, Member und Library hin. Die Verben deuten auf Methoden zum Ausleihen und Zurückgeben hin.

1. Liste auf, was jede Instanz weiß: Titel, Autor und Entleiher eines Buches; Name und ausgeliehene Bücher eines Mitglieds; Bücher und Mitglieder einer Bibliothek.
2. Bestimme die Regeln: Ein Buch darf nicht bereits ausgeliehen sein und ein Mitglied darf MAX_LOANS = 3 nicht überschreiten.
3. Setze jede Regel in die Operation, die die Beziehung verändert, etwa Library.check_out(book, member).
4. Schreibe die Initialisierung und eine nützliche Darstellung, ergänze und teste dann eine Aktion nach der anderen.

Unterschiedliche Titel benötigen unterschiedliche Instanzen von Book, keine eigenen Klassen für jeden Titel. Verwende für einzelne Objekte Substantive im Singular wie Book; benenne eine Sammlung nach der Sammlung, etwa Library. Halte die Aufgabe jeder Klasse so klar, dass du sie in einem Satz beschreiben kannst.

Beobachtbares Verhalten testen

acct = BankAccount("Maya", 50)
acct.deposit(25)
assert acct.balance == 75

assert löst AssertionError aus, wenn seine Bedingung falsch ist. Teste auch abgelehnte Aktionen: Fange die erwartete Ausnahme ab und prüfe, ob der Zustand unverändert geblieben ist. Verwende für Eingaben des aufrufenden Codes eine ausdrückliche Validierung mit raise; Zusicherungen sind Prüfungen während der Entwicklung und können deaktiviert werden, wenn Python mit Optimierung läuft.