Ga naar hoofdinhoud

Objectgeoriënteerd programmeren in Python: een complete gids

Leer de basis van objectgeoriënteerd programmeren in Python: classes, objecten, attributen en methoden stap voor stap uitgelegd met codevoorbeelden.
· 12 min lezen

Verken met AI

Objectgeoriënteerd programmeren (OOP) is een veelgebruikt concept om applicaties te schrijven. Als data scientist moet je applicaties kunnen schrijven om je data te verwerken, naast allerlei andere taken.

In deze tutorial behandel ik de basis van objectgeoriënteerd programmeren in Python. Je leert hoe je een class maakt en objecten instantieert, hoe je methoden definieert en er argumenten aan doorgeeft, en hoe je attributen aan een class toevoegt.

TL;DR

  • OOP organiseert code rond classes (blauwdrukken) en objecten (instanties van die blauwdrukken)

  • Definieer een class met het class-keyword en initialiseer attributen in __init__(self)

  • Instantiemethoden werken op objectdata via self en worden aangeroepen met puntnotatie: my_object.method()

  • Python ondersteunt alle vier OOP-pijlers: encapsulation, inheritance, polymorphism en abstraction

  • OOP bevordert hergebruik van code om meerdere objecten te maken vanuit één class-sjabloon

Wat is OOP?

Objectgeoriënteerd programmeren (OOP) is gebaseerd op het imperatieve programmeerparadigma, dat statements gebruikt om de toestand van een programma te veranderen. Imperatief betekent dat het zich richt op hóé een programma moet werken. Voorbeelden van imperatieve programmeertalen zijn C, C++, Java, Go, Ruby en Python.

Dit staat in contrast met declaratief programmeren, dat zich richt op wát het computerprogramma moet bereiken zonder te specificeren hoe (bijv. SQL, XQuery). Voor een vergelijking van paradigma’s, zie onze gids over functioneel programmeren vs. OOP.

OOP gebruikt de concepten objecten en classes. Een class kun je zien als een ‘blauwdruk’ voor objecten. Deze kunnen hun eigen

  • Attributen: eigenschappen die ze bezitten
  • Methoden: acties die ze uitvoeren

OOP heeft een paar belangrijke voordelen ten opzichte van andere ontwerpprincipes. Ontwikkeling is vaak sneller en goedkoper, en de modulaire aanpak maakt software makkelijker te onderhouden. Dit leidt op zijn beurt tot software van hogere kwaliteit, die ook uitbreidbaar is met nieuwe methoden en attributen.

De leercurve is echter langer. De kernconcepten vergen meer investering vooraf om volledig te begrijpen. Computationeel is OOP-software trager en gebruikt ze meer geheugen, omdat er meer code moet worden geschreven.

De vier pijlers van OOP

Naast classes en methoden rust OOP op vier pijlers die ik tot nu toe slechts kort heb aangestipt. Elk verdient een eigen deep dive, maar hier is een snel overzicht met links naar gerichte tutorials.

PijlerWat het betekentMeer leren
EncapsulationData en methoden bundelen en toegang beheren met naamconventies (_private, __name_mangled)Encapsulation in Python
InheritanceSubclasses maken die gedrag van de parent class hergebruiken en uitbreidenPython Inheritance
PolymorphismVerschillende classes delen dezelfde interface, zodat code uitwisselbaar met objecten kan werkenOOP in Python-cursus
AbstractionComplexiteit verbergen achter een nette interface met abstracte basisklassenPython Abstract Classes

OOP-voorbeeld

Een voorbeeld van een class is de class Dog. Denk niet aan een specifieke hond of je eigen hond. We beschrijven wat een hond in het algemeen is en kan doen. Honden hebben meestal een name en age; dit zijn instantie-attributen. Honden kunnen ook bark; dit is een methode.

Als je over een specifieke hond praat, heb je in programmeren een object: een object is een instantie van een class. Dit is het basisprincipe waarop objectgeoriënteerd programmeren is gebaseerd. Mijn hond Ozzy behoort bijvoorbeeld tot de class Dog. Zijn attributen zijn name = 'Ozzy' en age = '2'. Een andere hond heeft andere attributen.

OOP in Python

Python is een van de populairste talen om OOP te leren en toe te passen. Hieronder behandel ik waarom Python goed geschikt is voor objectgeoriënteerde code en loop ik door de kernsyntax.

Is Python objectgeoriënteerd?

Python is een geweldige programmeertaal die OOP ondersteunt. Je gebruikt het om een class met attributen en methoden te definiëren, die je vervolgens aanroept.

Het grootste voordeel van Python ten opzichte van andere programmeertalen zoals Java, C++ of R is dat het een dynamische taal is met high-level datatypes. Dit betekent dat de programmeur geen types voor variabelen en argumenten hoeft te declareren, wat ontwikkeling veel sneller maakt en code leesbaarder dan in Java of C++.

Als je nieuw bent met Python, bekijk dan zeker onze cursus Introduction to Python.

Hoe maak je een class

Om een class in Python te definiëren, gebruik je het class-keyword, gevolgd door de classnaam en een dubbele punt.

Binnen de class wordt typisch een __init__-methode (een dunder-methode) gedefinieerd met def. Dit is de initializer die je later kunt gebruiken om objecten te instantiëren. Het lijkt op een constructor in Java.

__init__ wordt automatisch aangeroepen wanneer je een nieuw object maakt. Het neemt één argument: self, dat verwijst naar het object zelf.

In de methode wordt voorlopig het keyword pass gebruikt, omdat Python verwacht dat je daar iets typt. Vergeet niet de juiste inspringing te gebruiken!

class Dog:

    def __init__(self):
        pass

Let op: self in Python is gelijk aan this in C++ of Java.

In dit geval heb je een (vrij lege) Dog-class, maar nog geen object. Laten we er één maken!

Objecten instantiëren

Om een object te instantiëren, typ je de classnaam gevolgd door twee haakjes. Je kunt dit aan een variabele toewijzen om het object bij te houden.

ozzy = Dog()

En print het:

print(ozzy)
<__main__.Dog object at 0x111f47278>

Attributen toevoegen aan een class

Na het printen van ozzy is duidelijk dat dit object een hond is. Maar je hebt nog geen attributen toegevoegd. Laten we de Dog-class een naam en leeftijd geven door hem te herschrijven:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

Je ziet dat de functie nu twee argumenten na self accepteert: name en age. Deze worden vervolgens respectievelijk toegewezen aan self.name en self.age. Je kunt nu een nieuw ozzy-object met een naam en leeftijd maken:

ozzy = Dog("Ozzy", 2)

Om attributen van een object in Python te benaderen, kun je de puntnotatie gebruiken. Dit doe je door de naam van het object te typen, gevolgd door een punt en de naam van het attribuut

print(ozzy.name)

print(ozzy.age)
Ozzy
2

Dit kan ook gecombineerd worden in een meer uitgebreide zin:

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")
Ozzy is 2 year(s) old.

De functie str() wordt hier gebruikt om het age-attribuut, een integer, om te zetten naar een string, zodat je het in de functie print() kunt gebruiken.

Methoden definiëren in een class

Nu je een Dog-class hebt, heeft die wel een naam en leeftijd die je kunt bijhouden, maar hij doet nog niets. Hier komen instantiemethoden van pas. Je kunt de class herschrijven zodat deze nu een bark()-methode bevat. Let op hoe het keyword def weer wordt gebruikt, net als het argument self.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

De bark-methode kan nu worden aangeroepen met de puntnotatie, nadat je een nieuw ozzy-object hebt geïnstantieerd. De methode zou "bark bark!" op het scherm moeten printen. Let op de haakjes in .bark(). Deze gebruik je altijd bij het aanroepen van een methode. Ze zijn in dit geval leeg, omdat de bark()-methode geen argumenten aanneemt.

ozzy = Dog("Ozzy", 2)

ozzy.bark()
bark bark!

Weet je nog dat je eerder ozzy printte? De onderstaande code implementeert deze functionaliteit nu in de Dog-class met de doginfo()-methode. Daarna instantieer je een paar objecten met verschillende eigenschappen en roep je de methode op voor elk van hen.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()
Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

Zoals je ziet, kun je de doginfo()-methode op objecten aanroepen met de puntnotatie. De respons hangt nu af van op welk Dog-object je de methode aanroept.

Omdat honden ouder worden, is het handig als je hun leeftijd dienovereenkomstig kunt aanpassen. Ozzy is net 3 geworden, dus laten we zijn leeftijd veranderen.

ozzy.age = 3

print(ozzy.age)
3