Python Object-Oriented Programming

Deze gids wandelt je door de kernconcepten van Python's Object-Oriented Programming (OOP), compleet met praktische voorbeelden die illustreren hoe je robuuste, herbruikbare code bouwt.

Video: Object-Oriented Programming in Python

Object-Oriented Programming

Python is een multi-paradigma taal die verschillende programmeringsstijlen ondersteunt. Een van de krachtigste benaderingen is het modelleren van problemen met objecten – een benadering bekend als Object-Oriented Programming (OOP).

Een object bezit twee essentiële kenmerken:

• Attributen (data)
• Gedrag (methoden)

Bijvoorbeeld, een papegaai is een object met attributen zoals naam, leeftijd en kleur, en gedragingen zoals zingen() en dansen().

OOP in Python bevordert herbruikbare code, volgens het DRY-principe (Don't Repeat Yourself).

Klasse

class is een blauwdruk die de structuur en het gedrag van objecten definieert. Denk eraan als een gedetailleerde schets van een papegaai: het specificeert welke eigenschappen en acties een papegaai kan hebben.

class Papegaai:
    pass

Hier is Papegaai een lege klasse. Instances van deze klasse worden later aangemaakt.

Object

Een object (of instantie) is een concrete realisatie van een klasse. Wanneer een klasse gedefinieerd wordt, wordt geen geheugen toegekend; alleen het sjabloon bestaat. Het instantiëren van de klasse creëert het object.

obj = Papegaai()

In het onderstaande voorbeeld bouwen we een functionele Papegaai-klasse en creëren twee instanties, blauw en woo:

class Papegaai:
    # Klasse-attribuut
    soort = "vogel"
    # Instantie-attributen
    def __init__(self, naam, leeftijd):
        self.naam = naam
        self.leeftijd = leeftijd

# Instantieer de klasse
blauw = Papegaai("Blauw", 10)
woo = Papegaai("Woo", 15)

# Toegang tot klasse-attributen
print("Blauw is een {}".format(blauw.__class__.soort))
print("Woo is ook een {}".format(woo.__class__.soort))

# Toegang tot instantie-attributen
print("{} is {} jaar oud".format(blauw.naam, blauw.leeftijd))
print("{} is {} jaar oud".format(woo.naam, woo.leeftijd))

Uitvoer

Blauw is een vogel Woo is ook een vogel Blauw is 10 jaar oud Woo is 15 jaar oud

In deze snippet is soort een klasse-attribuut gedeeld door alle papegaaien, terwijl naam en leeftijd instantie-attributen zijn uniek per object.

Methoden

Methoden zijn functies gedefinieerd binnen een klasse die objectgedrag beschrijven. Ze worden aangeroepen op instanties van de klasse.

class Papegaai:
    def __init__(self, naam, leeftijd):
        self.naam = naam
        self.leeftijd = leeftijd
    def zingen(self, liedje):
        return f"{self.naam} zingt {liedje}"
    def dansen(self):
        return f"{self.naam} dans nu"

# Instantieer en gebruik methoden
blauw = Papegaai("Blauw", 10)
print(blauw.zingen("'Blij'"))
print(blauw.dansen())

Uitvoer

Blauw zingt 'Blij' Blauw dans nu

Erfelijkheid (Inheritance)

Erfelijkheid laat een nieuwe klasse attributen en methoden erven van een bestaande klasse, wat codeherbruik en logische hiërarchie bevordert.

# Basisklasse
class Vogel:
    def __init__(self):
        print("Vogel is klaar")
    def wieIsDit(self):
        print("Vogel")
    def zwemmen(self):
        print("Zwem sneller")

# Afgeleide klasse
class Pinguin(Vogel):
    def __init__(self):
        super().__init__()
        print("Pinguin is klaar")
    def wieIsDit(self):
        print("Pinguin")
    def rennen(self):
        print("Ren sneller")

pegasus = Pinguin()
pegasus.wieIsDit()
pegasus.zwemmen()
pegasus.rennen()

Uitvoer

Vogel is klaar Pinguin is klaar Pinguin Zwem sneller Ren sneller

Encapsulatie

Encapsulatie beperkt directe toegang tot de interne staat van een object, wat dataintegriteit beschermt. In Python worden private attributen aangeduid met een leidende underscore (enkel of dubbel).

class Computer:
    def __init__(self):
        self.__maxprijs = 900
    def verkopen(self):
        print(f"Verkoopprijs: {self.__maxprijs}")
    def setMaxPrijs(self, prijs):
        self.__maxprijs = prijs

c = Computer()
c.verkopen()
# Poging om direct te wijzigen
c.__maxprijs = 1000
c.verkopen()
# Setter-methode gebruiken
c.setMaxPrijs(1000)
c.verkopen()

Uitvoer

Verkoopprijs: 900 Verkoopprijs: 900 Verkoopprijs: 1000

Polymorfisme

Polymorfisme stelt objecten van verschillende klassen in staat om via een gedeelde interface te worden behandeld, wat flexibele code mogelijk maakt die op diverse objecttypen kan opereren.

class Papegaai:
    def vliegen(self):
        print("Papegaai kan vliegen")
    def zwemmen(self):
        print("Papegaai kan niet zwemmen")

class Pinguin:
    def vliegen(self):
        print("Pinguin kan niet vliegen")
    def zwemmen(self):
        print("Pinguin kan zwemmen")

# Gemeenschappelijke interface
def vliegtest(vogel):
    vogel.vliegen()

blauw = Papegaai()
pegasus = Pinguin()
vliegtest(blauw)
vliegtest(pegasus)

Uitvoer

Papegaai kan vliegen Pinguin kan niet vliegen

Kernpunten

• OOP structureert code voor duidelijkheid en onderhoudbaarheid.
• Klassen maken codeherbruik mogelijk via erfelijkheid.
• Encapsulatie bewaart interne data.
• Polymorfisme biedt flexibele interfaces over objecttypen.