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
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
selfen 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
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.
_private,__name_mangled)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 eennameenage; dit zijn instantie-attributen. Honden kunnen ookbark; 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 zijnname = 'Ozzy'enage = '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 metdef. 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
passgebruikt, omdat Python verwacht dat je daar iets typt. Vergeet niet de juiste inspringing te gebruiken!Let op:
selfin Python is gelijk aanthisin C++ of Java.In dit geval heb je een (vrij lege)
Dog-class, maar nog geen object. Laten we er één maken!