Ausführbare Python-Docs: Vererbung

Q: Was macht super().__init__()?

Es ruft das init der Elternklasse auf, damit die Elternklasse ihre eigenen Attribute einrichten kann. Wenn eine Unterklasse ein eigenes init definiert, ruft Python das der Elternklasse nicht automatisch auf. Du rufst also super().init(...) mit den Argumenten auf, die die Elternklasse braucht, und setzt danach die zusätzlichen Attribute der Unterklasse.

Q: Was ist der Unterschied zwischen isinstance und type in Python?

isinstance(obj, Animal) ist True für ein Animal und für Instanzen jeder Unterklasse von Animal. type(obj) is Animal ist nur True, wenn das Objekt direkt aus Animal erzeugt wurde. Nimm lieber isinstance, weil es weiter funktioniert, wenn jemand eine Unterklasse hinzufügt.

Q: Unterstützt Python Mehrfachvererbung?

Ja: class C(A, B): erbt von beiden. Wenn beide Elternklassen dieselbe Methode definieren, wählt Python eine anhand der Method Resolution Order (MRO), die du mit C.mro ansehen kannst. Sie nennt zuerst C, dann die Elternklassen von links nach rechts und zuletzt object.

Eine Klasse, die auf einer anderen aufbaut

Mit Vererbung definierst du eine neue Klasse als Erweiterung einer vorhandenen. Die vorhandene Klasse ist die Elternklasse (auch Basisklasse oder Oberklasse genannt), die neue ist die Kindklasse (Unterklasse). Die Kindklasse bekommt jede Methode und jedes Klassenattribut der Elternklasse, ohne sie zu wiederholen, und kann eigene hinzufügen oder die ersetzen, die sich anders verhalten sollen.

Die Elternklasse gibst du in Klammern hinter dem Klassennamen an:

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

    def describe(self):
        return f"{self.name} is an animal"

    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Woof"

rex = Dog("Rex")
print(rex.describe())   # inherited from Animal
print(rex.speak())      # defined in Dog

Ausgabe:

Rex is an animal
Woof

Dog hat weder ein eigenes __init__ noch ein eigenes describe. Wenn du Dog("Rex") aufrufst, sucht Python __init__ auf Dog, findet es nicht und nimmt das von Animal. Dieselbe Suche passiert bei rex.describe(). Bei rex.speak() findet Python speak zuerst auf Dog und hört dort auf.

Diese Suchreihenfolge ist der ganze Mechanismus: Python durchsucht die eigene Klasse des Objekts, dann die Elternklasse, dann deren Elternklasse, und nimmt den ersten Treffer. Wenn Klassen neu für dich sind, erklärt die Seite zu Klassen zuerst __init__, self und Methoden.

Eine Methode überschreiben

Eine Methode in der Kindklasse mit demselben Namen wie eine in der Elternklasse ersetzt diese für Instanzen der Kindklasse. Das nennt man Überschreiben. Jede Unterklasse kann denselben Aufruf auf ihre eigene Art beantworten:

class Shape:
    def area(self):
        return 0

    def summary(self):
        return f"{type(self).__name__} with area {self.area()}"

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

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

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

shapes = [Rectangle(3, 4), Square(5), Shape()]
for shape in shapes:
    print(shape.summary())

Ausgabe:

Rectangle with area 12
Square with area 25
Shape with area 0

summary ist nur einmal definiert, auf Shape, ruft aber self.area() auf. Weil self das tatsächliche Objekt ist, führt ein Rectangle Rectangle.area aus, und ein Square findet area bei seiner Elternklasse Rectangle. Der Code der Elternklasse ruft die Methode der Kindklasse auf, ohne zu wissen, dass es die Kindklasse gibt. Genau das macht Vererbung nützlich: Ein gemeinsamer Ablauf wird geteilt, und jede Unterklasse füllt die Details aus.

Die Elternklasse mit super() aufrufen

Wenn eine Kindklasse ein eigenes __init__ definiert, läuft das __init__ der Elternklasse nicht mehr von selbst. Braucht die Kindklasse trotzdem die Einrichtung der Elternklasse, ruf sie mit super().__init__() auf:

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

    def deposit(self, amount):
        self.balance += amount

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, rate=0.02):
        super().__init__(owner, balance)   # let Account set owner and balance
        self.rate = rate                   # then add what is new

    def add_interest(self):
        self.deposit(self.balance * self.rate)

acct = SavingsAccount("Ada", 1000, rate=0.05)
acct.add_interest()
print(acct.owner, acct.balance)

Ausgabe:

Ada 1050.0

super() liefert ein Objekt, das Methoden ab der Elternklasse der aktuellen Klasse sucht. super().__init__(owner, balance) führt deshalb Account.__init__ auf demselben Objekt aus, und danach existieren self.owner und self.balance.

Lässt du diese Zeile weg, ist das Objekt nur halb aufgebaut:

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

class SavingsAccount(Account):
    def __init__(self, owner, rate):
        self.rate = rate   # forgot super().__init__(owner)

acct = SavingsAccount("Ada", 0.05)
print(acct.rate)

try:
    print(acct.owner)
except AttributeError as err:
    print("AttributeError:", err)

Ausgabe:

0.05
AttributeError: 'SavingsAccount' object has no attribute 'owner'

Du kannst stattdessen Account.__init__(self, owner) schreiben, und älterer Code tut das oft. super() ist vorzuziehen, weil es den Namen der Elternklasse nicht wiederholt und mit Mehrfachvererbung korrekt zusammenarbeitet, die weiter unten behandelt wird.

Eine Methode erweitern statt ersetzen

super() funktioniert in jeder Methode, nicht nur in __init__. Wenn du innerhalb einer überschriebenen Methode die Version der Elternklasse aufrufst, kannst du Verhalten drumherum ergänzen, statt sie neu zu schreiben:

class Logger:
    def format(self, message):
        return message

    def log(self, message):
        print(self.format(message))

class TimestampLogger(Logger):
    def format(self, message):
        base = super().format(message)
        return f"[12:00] {base}"

class LevelLogger(TimestampLogger):
    def format(self, message):
        return "INFO " + super().format(message)

Logger().log("started")
TimestampLogger().log("started")
LevelLogger().log("started")

Ausgabe:

started
[12:00] started
INFO [12:00] started

Jede Stufe fügt ein Stück hinzu und reicht den Rest nach oben weiter. Ändert sich format in der Elternklasse später, übernehmen beide Kindklassen die Änderung.

isinstance und issubclass

Eine Instanz einer Unterklasse ist auch eine Instanz jeder Klasse darüber. isinstance(obj, cls) prüft diese Beziehung, und issubclass(child, parent) prüft sie zwischen zwei Klassen:

class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

rex = Dog()

print(isinstance(rex, Dog))       # True
print(isinstance(rex, Animal))    # True: a Dog is an Animal
print(isinstance(rex, Cat))       # False
print(isinstance(rex, (Cat, Dog)))  # True: matches any class in the tuple

print(issubclass(Dog, Animal))    # True
print(issubclass(Animal, Dog))    # False
print(issubclass(Dog, Dog))       # True: a class counts as its own subclass

print(type(rex) is Animal)        # False: type() ignores inheritance

Nimm lieber isinstance, statt type(obj) direkt zu vergleichen. Eine Prüfung wie type(obj) is Animal lehnt jede Unterklasse ab und geht kaputt, sobald jemand Dog hinzufügt.

Jede Klasse, die du schreibst, erbt von object, auch wenn du es nicht hinschreibst. class Animal: ist dasselbe wie class Animal(object):. Daher kommen Standardmethoden wie __str__, __repr__ und __eq__, und deshalb ändert ein überschriebenes __str__, was print() anzeigt:

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

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

print(Point(2, 3))
print(issubclass(Point, object))

Ausgabe:

(2, 3)
True

Unterklassen zwingen, eine Methode zu implementieren

Manchmal soll die Elternklasse nie direkt verwendet werden, sondern nur als Vorlage dienen. Das Modul abc kennzeichnet eine solche Klasse als abstrakt. Jede Methode mit dem Dekorator @abstractmethod muss überschrieben werden, bevor sich die Klasse instanziieren lässt:

from abc import ABC, abstractmethod

class Exporter(ABC):
    @abstractmethod
    def export(self, rows):
        ...

    def run(self, rows):
        print(f"exporting {len(rows)} rows")
        return self.export(rows)

class CsvExporter(Exporter):
    def export(self, rows):
        return "\n".join(",".join(map(str, row)) for row in rows)

print(CsvExporter().run([[1, 2], [3, 4]]))

try:
    Exporter()
except TypeError as err:
    print("TypeError:", err)

Die ersten drei Ausgabezeilen sind der Export:

exporting 2 rows
1,2
3,4

Die letzte Zeile ist ein TypeError, der Exporter und die fehlende Methode export nennt (der genaue Wortlaut unterscheidet sich zwischen Python-Versionen). Der Fehler zeigt sich beim Erzeugen des Objekts, nicht erst später, wenn export schließlich aufgerufen wird.

Mehrfachvererbung und die MRO

Eine Klasse kann mehr als eine Elternklasse angeben. Dann erbt sie von allen:

class Swimmer:
    def move(self):
        return "swims"

    def swim(self):
        return "paddling"

class Flyer:
    def move(self):
        return "flies"

    def fly(self):
        return "flapping"

class Duck(Swimmer, Flyer):
    pass

d = Duck()
print(d.swim(), d.fly())
print(d.move())
print([cls.__name__ for cls in Duck.__mro__])

Ausgabe:

paddling flapping
swims
['Duck', 'Swimmer', 'Flyer', 'object']

Beide Elternklassen definieren move, und Duck bekommt die Version von Swimmer. Python entscheidet das über die Method Resolution Order (MRO): eine einzige Liste von Klassen, gespeichert in Duck.__mro__, die jede Attributsuche von vorn nach hinten abläuft. Sie beginnt mit der Klasse selbst, behält die Elternklassen in der Reihenfolge, in der du sie angegeben hast, stellt jede Klasse vor ihre eigenen Elternklassen und endet mit object. Vertauschst du die Reihenfolge zu class Duck(Flyer, Swimmer), liefert move den Wert "flies".

super() folgt derselben Liste. In einer Methode von Swimmer bedeutet super() „die nächste Klasse nach Swimmer in der MRO der Klasse des Objekts“, und das ist bei einem Duck die Klasse Flyer, nicht object. So können kooperative Klassen jeweils super() aufrufen, und jede Klasse in der Kette läuft genau einmal, selbst in einer Raute, in der zwei Elternklassen eine gemeinsame Großelternklasse haben.

In der Praxis wird Mehrfachvererbung vor allem für Mixins verwendet: kleine Klassen, die eine einzelne Fähigkeit hinzufügen, etwa ein JsonMixin mit einer Methode to_json, kombiniert mit einer Hauptelternklasse. Tiefe Hierarchien mit mehreren vollständigen Elternklassen sind schwer nachzuvollziehen und selten nötig.

Vererbung oder Komposition?

Vererbung bildet eine „ist ein“-Beziehung ab. Ein SavingsAccount ist ein Account: Jeder Code, der mit einem Account arbeitet, sollte unverändert auch damit funktionieren. Wenn dieser Satz falsch klingt, willst du wahrscheinlich Komposition, die „hat ein“ abbildet: Das Objekt hält ein anderes Objekt als Attribut und ruft es auf.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return f"{self.horsepower} hp engine running"

class Car:
    def __init__(self, model, engine):
        self.model = model
        self.engine = engine   # a Car has an Engine

    def start(self):
        return f"{self.model}: {self.engine.start()}"

car = Car("Roadster", Engine(300))
print(car.start())

Ausgabe:

Roadster: 300 hp engine running

class Car(Engine) würde auch laufen, würde aber behaupten, ein Auto sei eine Art Motor. Car bekäme jede Motormethode, und ein anderer Motor ließe sich nur mit einer anderen Klasse einbauen. Mit Komposition bleiben die Teile getrennt, und den Motor zu tauschen heißt nur, ein anderes Objekt zu übergeben.

Ein paar Anzeichen, dass Vererbung das falsche Werkzeug ist:

Die Kindklasse überschreibt die meisten Methoden der Elternklasse oder schaltet einige davon ab.
Du erbst nur, um eine oder zwei Hilfsmethoden wiederzuverwenden.
Die Hierarchie wächst über zwei oder drei Ebenen hinaus, und du musst mehrere Dateien lesen, um zu sehen, was eine Methode tut.

Häufige Fehler

super().__init__() vergessen. Das __init__ der Kindklasse ersetzt das der Elternklasse, also werden die Attribute der Elternklasse nie gesetzt, und später kommt ein AttributeError.
self an super()-Aufrufe übergeben. Schreib super().__init__(name), nicht super().__init__(self, name). super() bindet die Methode bereits an das aktuelle Objekt.
Unpassende Signaturen beim Überschreiben. Wenn gemeinsamer Code speak(self) der Elternklasse aufruft, bricht ein speak(self, volume) in der Kindklasse mit einem zusätzlichen Pflichtargument diesen Code. Halte Überschreibungen kompatibel oder gib neuen Parametern Standardwerte.
type(obj) == SomeClass prüfen. Das ignoriert Unterklassen. Nimm isinstance.
Vererbung nutzen, um Code zwischen nicht verwandten Klassen zu teilen. Verschieb den gemeinsamen Code stattdessen in eine Funktion oder ein Hilfsobjekt.

Häufig gestellte Fragen

Wie erbt man in Python von einer Klasse?

Schreib die Elternklasse in Klammern hinter den Namen der neuen Klasse: class Dog(Animal):. Dog bekommt jede Methode und jedes Klassenattribut von Animal und kann neue hinzufügen oder vorhandene überschreiben.

Was macht super().__init__()?

Es ruft das __init__ der Elternklasse auf, damit die Elternklasse ihre eigenen Attribute einrichten kann. Wenn eine Unterklasse ein eigenes __init__ definiert, ruft Python das der Elternklasse nicht automatisch auf. Du rufst also super().__init__(...) mit den Argumenten auf, die die Elternklasse braucht, und setzt danach die zusätzlichen Attribute der Unterklasse.

Was ist der Unterschied zwischen isinstance und type in Python?

isinstance(obj, Animal) ist True für ein Animal und für Instanzen jeder Unterklasse von Animal. type(obj) is Animal ist nur True, wenn das Objekt direkt aus Animal erzeugt wurde. Nimm lieber isinstance, weil es weiter funktioniert, wenn jemand eine Unterklasse hinzufügt.

Unterstützt Python Mehrfachvererbung?

Ja: class C(A, B): erbt von beiden. Wenn beide Elternklassen dieselbe Methode definieren, wählt Python eine anhand der Method Resolution Order (MRO), die du mit C.__mro__ ansehen kannst. Sie nennt zuerst C, dann die Elternklassen von links nach rechts und zuletzt object.

Wann sollte ich Komposition statt Vererbung verwenden?

Nimm Vererbung für eine „ist ein“-Beziehung, bei der die Unterklasse überall einsetzbar ist, wo die Elternklasse erwartet wird (ein SavingsAccount ist ein Account). Nimm Komposition, also ein Objekt als Attribut speichern, für eine „hat ein“-Beziehung (ein Car hat eine Engine). Im Zweifel lässt sich Komposition später leichter ändern.

Verwandte Konzepte