Python Academy · Les

Methoden overschrijven en super()

Overschrijf methoden van een parent en roep ze aan met super().

Les 2 van 414 stappen

Methoden overschrijven en super() is een gratis Python Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

Inleiding

Met het overschrijven van methoden kunnen subklassen overgeërfd gedrag aanpassen. Met super() kun je de oorspronkelijke implementatie aanroepen.

Basisprincipes van overschrijven

Definieer dezelfde methodenaam in de subklasse om de versie van de bovenliggende klasse te vervangen voor alle instanties van de subklasse.

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

super() bij overschrijven

super().greet() in de subklasse roept de versie van de bovenliggende klasse aan. Dit is nuttig om gedrag uit te breiden in plaats van het volledig te vervangen.

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

Roep altijd super().__init__() aan in de __init__ van een subklasse, zodat de initialisatie van de bovenliggende klasse wordt uitgevoerd.

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() met argumenten

super(ChildClass, self) is de expliciete vorm, zoals in Python 2. In Python 3 kun je in de meeste gevallen super() zonder argumenten gebruiken.

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

Coöperatieve overerving

Bij meervoudige overerving volgt super() de MRO. Elke klasse die super() aanroept, zorgt ervoor dat alle klassen in de keten worden geïnitialiseerd.

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 overschrijven

Overschrijf __str__ in de subklasse om aan te passen hoe instanties worden afgedrukt.

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

Patroon voor sjabloonmethoden

De bovenliggende klasse definieert de structuur van het algoritme; de subklasse vult de stappen in door specifieke methoden te overschrijven.

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

Een methode van een zusterklasse aanroepen

Met super() en de juiste MRO kun je bij meervoudige overerving een methode van een zusterklasse aanroepen — dit is coöperatieve 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__ wordt aangeroepen telkens wanneer er een subklasse van de klasse wordt gemaakt. Dit is nuttig voor patronen voor plug-inregistratie.

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

Wanneer je NIET moet overschrijven

Overschrijf een methode niet als je het gedrag niet hoeft te veranderen. Onnodige overschrijvingen zorgen voor extra onderhoud. Geef voor niet-gerelateerd gedrag de voorkeur aan compositie.

# 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')

Korte controle

Waarnaar verwijst super() (zonder argumenten) binnen een methode in Python 3?

Beantwoord dit in de interactieve les

Samenvatting

Overschrijf een methode door deze opnieuw te definiëren in de subklasse. super().method() roept de versie van de bovenliggende klasse aan. super().__init__() initialiseert de bovenliggende klasse. Coöperatieve super() volgt de volgorde van de MRO.

Ga door

Uitstekende voortgang! Ga door om het volgende concept onder de knie te krijgen.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 76
Lessen: 320

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Methoden overschrijven en super()” gratis?

Ja — de volledige tekst van “Methoden overschrijven en super()” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “Methoden overschrijven en super()”?

Overschrijf methoden van een parent en roep ze aan met super(). Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Methoden overschrijven en super()”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Python Academy