Python-erfelijkheid

Erfelijkheid laat je een nieuwe klasse aanmaken die alle functionaliteit erft van een parent-klasse terwijl je features toevoegt of uitbreidt. Deze tutorial legt uit hoe je erfelijkheid in Python gebruikt, met duidelijke voorbeelden en best-practice begeleiding.

Video: Python-erfelijkheid

Erfelijkheid in Python

Erfelijkheid is een kernprincipe van object-georiënteerd programmeren dat codeherbruik en logische hiërarchie bevordert. Een nieuwe klasse (de afgeleide of kind-klasse) wordt gedefinieerd met minimale of geen wijzigingen aan een bestaande klasse (de basis of ouder-klasse). De kind-klasse ontvangt automatisch de attributen en methoden van de ouder, die daarna overschreven of uitgebreid kunnen worden naar wens.

Python-erfelijkheidssyntax

class BasisKlasse:
    # body van basisklasse
class AfgeleideKlasse(BasisKlasse):
    # body van afgeleide klasse

In het bovenstaande snippet erft AfgeleideKlasse alle publieke members van BasisKlasse. Door nieuwe methoden toe te voegen of bestaande te overschrijven, kan de afgeleide klasse gedrag aanpassen terwijl de basisimplementatie herbruikt wordt.

Voorbeeld van erfelijkheid in Python

Laten we erfelijkheid illustreren met een praktisch voorbeeld. Stel we hebben een generieke Veelhoek-klasse die het aantal zijden en hun lengtes opslaat:

class Veelhoek:
    def __init__(self, aantal_zijden):
        self.n = aantal_zijden
        self.zijden = [0 for _ in range(aantal_zijden)]
    def invoer_zijden(self):
        self.zijden = [float(input(f"Voer zijde {i+1} in: ")) for i in range(self.n)]
    def toon_zijden(self):
        for i, zijde in enumerate(self.zijden, 1):
            print(f"Zijde {i} is {zijde}")

De Veelhoek-klasse incapsuleert gemeenschappelijke attributen en methoden voor elke veelhoek. Een Driehoek is een specifieke veelhoek met precies drie zijden, dus het kan erven van Veelhoek zonder de gedeelde logica te herdefiniëren:

class Driehoek(Veelhoek):
    def __init__(self):
        super().__init__(3)  # initialiseer basis met 3 zijden
    def bereken_oppervlakte(self):
        a, b, c = self.zijden
        s = (a + b + c) / 2
        oppervlakte = (s * (s - a) * (s - b) * (s - c)) ** 0.5
        print(f"De oppervlakte van de driehoek is {oppervlakte:.2f}")

Het uitvoeren van het volgende demonstreert de erfelijkheid in actie:

>>> d = Driehoek()
>>> d.invoer_zijden()
Voer zijde 1 in: 3
Voer zijde 2 in: 5
Voer zijde 3 in: 4
>>> d.toon_zijden()
Zijde 1 is 3.0
Zijde 2 is 5.0
Zijde 3 is 4.0
>>> d.bereken_oppervlakte()
De oppervlakte van de driehoek is 6.00

Let op dat Driehoek invoer_zijden() en toon_zijden() kan aanroepen zelfs al definieert het ze niet – erfelijkheid maakt deze methoden automatisch beschikbaar.

Als een attribuut of methode niet in de kind-klasse gevonden wordt, zoekt Python in de ouder-klasse, en deze lookup gaat door de erfelijkheidsketen omhoog indien nodig.

Methode overschrijven in Python

Zowel Veelhoek als Driehoek definiëren een __init__-methode. De kind-implementatie overschrijft de ouder-implementatie, maar kan (en moet) de basislogica uitbreiden door deze expliciet aan te roepen. Het gebruik van super() is de moderne, voorkeursbenadering:

class Driehoek(Veelhoek):
    def __init__(self):
        super().__init__(3)  # roept Veelhoek.__init__ aan

Bij overschrijven kan de kind-methode nieuw gedrag toevoegen of het basisgedrag wijzigen terwijl de originele functionaliteit bewaard blijft.

Python biedt isinstance() en issubclass() om erfelijkheidsrelaties te introspecteren:

d = Driehoek()
print(isinstance(d, Driehoek))  # True
print(isinstance(d, Veelhoek))  # True
print(isinstance(d, int))       # False
print(isinstance(d, object))    # True
print(issubclass(Veelhoek, Driehoek))  # False
print(issubclass(Driehoek, Veelhoek))  # True
print(issubclass(bool, int))           # True

Deze hulpmiddelen zijn essentieel voor type-checking en waarborgen dat objecten voldoen aan verwachte interfaces.

Meer over super() in de Python super() functie documentatie.