Objectgeoriënteerd programmeren in Python: een complete gids

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

Het is zo eenvoudig als een nieuwe waarde aan het attribuut toekennen. Je zou dit ook als een birthday()-methode in de Dog-class kunnen implementeren:

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.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

Nu hoef je de leeftijd van de hond niet handmatig te veranderen. Wanneer hij jarig is, kun je gewoon de birthday()-methode aanroepen. 

Argumenten doorgeven aan methoden

Je wilt graag dat onze honden een buddy hebben. Dit moet optioneel zijn, omdat niet alle honden even sociaal zijn.

Bekijk de setBuddy()-methode hieronder. Die neemt zoals gebruikelijk self en buddy als argumenten. In dit geval is buddy een ander Dog-object. Stel het attribuut self.buddy in op buddy, en het attribuut buddy.buddy op self.

Dit betekent dat de relatie wederkerig is: je bent de buddy van je buddy. In dit geval wordt Filou Ozzy’s buddy, wat betekent dat Ozzy automatisch Filou’s buddy wordt.

Je zou deze attributen ook handmatig kunnen instellen in plaats van een methode te definiëren, maar dat kost meer werk (twee regels code schrijven in plaats van één) elke keer dat je een buddy wilt instellen.

Let op dat je in Python niet hoeft te specificeren welk type het argument is. In Java zou dat wel vereist zijn.

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.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

Je kunt de methode nu met de puntnotatie aanroepen en er een ander Dog-object aan doorgeven. In dit geval wordt Filou Ozzy’s buddy:

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

ozzy.setBuddy(filou)

Als je nu informatie over Ozzy’s buddy wilt ophalen, kun je de puntnotatie twee keer gebruiken: eerst om naar Ozzy’s buddy te verwijzen, en een tweede keer om naar zijn attribuut te verwijzen.

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

Merk op dat dit ook voor Filou kan.

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

De methoden van de buddy kunnen ook worden aangeroepen. Het self-argument dat aan doginfo() wordt doorgegeven is nu ozzy.buddy, oftewel filou.

ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Python OOP-voorbeeld

Een voorbeeld waar objectgeoriënteerd programmeren in Python handig kan zijn, is onze tutorial Python For Finance: Algorithmic Trading. Daarin leggen we uit hoe je een tradingstrategie opzet voor een aandelenportefeuille.

De tradingstrategie is gebaseerd op het voortschrijdend gemiddelde van een aandelenkoers. Als signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] waar is, wordt een signaal gecreëerd. Dit signaal is een voorspelling voor de toekomstige koersverandering van het aandeel.

In de onderstaande code zie je dat er eerst een initialisatie is, gevolgd door de berekening van het voortschrijdend gemiddelde en het genereren van signalen. Omdat dit geen objectgeoriënteerde code is, is het gewoon één groot blok dat in één keer wordt uitgevoerd.

Let op dat we in het voorbeeld aapl gebruiken, de tickersymbol van Apple. Als je dit voor een ander aandeel wilt doen, moet je de code herschrijven.

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

In een objectgeoriënteerde aanpak hoef je de initialisatie- en signaalgeneratiecode maar één keer te schrijven.

Je kunt vervolgens voor elk aandeel waarvoor je een strategie wilt berekenen een nieuw object maken en daarop de methode generate_signals() aanroepen. Merk op dat de OOP-code erg lijkt op de code hierboven, met de toevoeging van self.

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = self.bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

Je kunt nu eenvoudig een object instantiëren met de parameters die je wilt en daar signalen voor genereren.

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

Dit voor een ander aandeel doen wordt heel eenvoudig. Het is slechts een kwestie van een nieuw object instantiëren met een ander tickersymbool.

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

Tot slot

We hebben enkele van de belangrijkste OOP-concepten in Python behandeld. Je weet nu hoe je classes en methoden declareert, objecten instantieert, hun attributen instelt en instantiemethoden aanroept. Deze skills komen van pas in je toekomstige carrière als data scientist.

Voor een modernere manier om classes te definiëren, bekijk Python data classes, die boilerplate-code verminderen. Wil je de sleutelconcepten uitbreiden die je nodig hebt om verder met Python te werken, bekijk dan zeker onze cursus Intermediate Python.

Met OOP wordt je code complexer naarmate je programma groter wordt. Je krijgt verschillende classes, subclasses, objecten, inheritance, instantiemethoden en meer. Voor complexe overervingsscenario’s, leer over multiple inheritance en super().