Python Academy · Lektion

Methodenüberschreibung und super()

Überschreiben Sie Methoden der Elternklasse und rufen Sie sie mit super() auf.

Methodenüberschreibung und super() ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Einführung

Das Überschreiben von Methoden ermöglicht es Unterklassen, geerbtes Verhalten anzupassen. Mit super() können Sie die ursprüngliche Implementierung aufrufen.

Grundlagen des Überschreibens

Definieren Sie in der Unterklasse denselben Methodennamen, um die Version der Oberklasse für alle Instanzen der Unterklasse zu ersetzen.

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

super() beim Überschreiben

super().greet() innerhalb der Unterklasse ruft die Version der Oberklasse auf. Das ist nützlich, wenn Sie Verhalten erweitern, statt es vollständig zu ersetzen.

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

super() in init

Rufen Sie super().__init__() im __init__ einer Unterklasse immer auf, damit die Initialisierung der Oberklasse ausgeführt wird.

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

super() mit Argumenten

super(ChildClass, self) ist die explizite Form im Python-2-Stil. Python 3 erlaubt super() in den meisten Fällen ohne Argumente.

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

Kooperative Vererbung

Bei Mehrfachvererbung folgt super() der MRO. Wenn jede Klasse super() aufruft, werden alle Klassen in der Kette initialisiert.

class A:
    def __init__(self): print('A init')
class B(A):
    def __init__(self): super().__init__(); print('B init')
class C(A):
    def __init__(self): super().__init__(); print('C init')
class D(B, C):
    def __init__(self): super().__init__(); print('D init')
D()

str überschreiben

Überschreiben Sie __str__ in der Unterklasse, um anzupassen, wie Instanzen ausgegeben werden.

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

Template-Method-Muster

Die Oberklasse definiert das Grundgerüst des Algorithmus. Die Unterklasse füllt die einzelnen Schritte durch das Überschreiben bestimmter Methoden aus.

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

Eine Methode einer Geschwisterklasse aufrufen

Mit super() und einer passenden MRO können Sie bei Mehrfachvererbung die Methode einer Geschwisterklasse aufrufen – dies ist kooperatives super().

class A:
    def hello(self): print('A')
class B(A):
    def hello(self): super().hello(); print('B')
class C(A):
    def hello(self): super().hello(); print('C')
class D(B,C):
    def hello(self): super().hello(); print('D')
D().hello()

__init_subclass__

__init_subclass__ wird aufgerufen, sobald die Klasse als Unterklasse verwendet wird. Das ist nützlich für Muster zur Plugin-Registrierung.

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

Wann Sie NICHT überschreiben sollten

Überschreiben Sie eine Methode nicht, wenn Sie das Verhalten nicht ändern müssen. Unnötige Überschreibungen erhöhen den Wartungsaufwand. Bevorzugen Sie für unabhängiges Verhalten Komposition.

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

Kurzer Test

Worauf verweist super() ohne Argumente innerhalb einer Methode in Python 3?

Zusammenfassung

Überschreiben durch Neudefinition in der Unterklasse. super().method() ruft die Version der Oberklasse auf. super().__init__() initialisiert die Oberklasse. Kooperatives super() folgt der Reihenfolge der MRO.

Weiter

Hervorragender Fortschritt! Fahren Sie fort, um das nächste Konzept zu beherrschen.

Häufig gestellte Fragen

Ist die Lektion „Methodenüberschreibung und super()“ kostenlos?

Ja — der vollständige Text von „Methodenüberschreibung und super()“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Methodenüberschreibung und super()“?

Überschreiben Sie Methoden der Elternklasse und rufen Sie sie mit super() auf. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Methodenüberschreibung und super()“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy