Functioneel programmeren vs objectgeoriënteerd programmeren in data-analyse

Een goede structuur is een kenmerk van goed geschreven code. De aard van die structuur wordt bepaald door het gebruikte programmeerparadigma. Een programmeerparadigma is een samenhangende set principes en technieken die de aanpak bepalen bij het ontwerpen en coderen van computerprogramma’s.

Er zijn veel programmeerparadigma’s, zoals procedureel, imperatief, declaratief, objectgeoriënteerd en functioneel. Sommige talen zijn beperkt tot slechts een paar paradigma’s. Zo is SQL een declaratieve taal. Veel moderne talen, waaronder Python, ondersteunen echter meerdere programmeerparadigma’s, wat flexibiliteit biedt.

Oefen met het schrijven van pure functies met een praktische oefening uit onze cursus Introduction to Programming Paradigms. 

Veel programmeurs vallen terug op een voorkeursparadigma, vaak datgene dat ze als eerste hebben geleerd. Meer gevorderde programmeurs begrijpen de voordelen en zwaktes van deze paradigma’s en kunnen elk van hun sterke punten benutten in verschillende scenario’s. Laten we twee van de meest gebruikte programmeerparadigma’s in data science doornemen: functioneel programmeren en objectgeoriënteerd programmeren.

Wat is functioneel programmeren (FP)?

Bij functioneel programmeren wordt code opgebouwd door functies te definiëren en te gebruiken die bepalen hoe het programma moet werken. Het is een subtype van het declaratieve programmeerparadigma.

Functies zijn regels code die argumenten aannemen en uitvoer teruggeven. Een eenvoudige functie kan bijvoorbeeld een lijst met getallen als argument nemen en alleen de even waarden teruggeven.

def get_even_numbers(list):
    return [num for num in list if num % 2 == 0]Mogelijk gemaakt door

Bekijk deze cursussen om de best practices voor het schrijven van functies in Python en R te leren.

Functioneel programmeren valt op door zijn traceerbaarheid en voorspelbaarheid. Dit komt doordat de gebruikte functies onveranderlijk zijn, wat betekent dat ze niet aangepast kunnen worden. Functies worden gedefinieerd, vaak in een apart gedeelte van de code (of soms in een ander bestand), en vervolgens waar nodig in de code gebruikt. Deze eigenschap maakt het gemakkelijk om te bepalen wat er in een stuk code gebeurt, omdat de functie overal op dezelfde manier werkt en wordt aangeroepen.

Het concept van onveranderlijkheid strekt zich in functioneel programmeren ook uit tot datastructuren. In FP geef je er de voorkeur aan een kopie van de data te maken wanneer je de staat wijzigt. Dit legt als het ware een papieren spoor vast van alle transformaties die op de data zijn toegepast, wat de traceerbaarheid vergroot en het opsporen van problemen vereenvoudigt. Het is echter belangrijk op te merken dat deze aanpak vaak leidt tot een hoger geheugengebruik, omdat bij elke statuswijziging de volledige dataset wordt gekopieerd.

Een subset van functies die in functioneel programmeren worden gebruikt, zijn hogere-orde-functies. Dit zijn functies die een functie als argument nemen of een functie als resultaat teruggeven. Je kunt bijvoorbeeld een hogere-orde-functie hebben die een functie meerdere keren uitvoert, zoals hieronder getoond, of een die de juiste functie kiest voor een specifieke situatie.

def run_function_multiple_times(function, num_times):
	for i in range(num_times):
        function()Mogelijk gemaakt door

Voordelen van functioneel programmeren in data-analyse

Functioneel programmeren biedt een structuur om duplicatie in je code te verminderen. Het doel is om herhaalde handelingen gemakkelijk te kunnen uitdrukken met hoog-niveau werkwoorden.

Stel dat je op meerdere plaatsen in je code strings moet aanpassen aan een bepaald formaat. Dit formaat vereist dat je spaties, interpunctie en cijfers verwijdert en alles lowercase maakt. Je zou dan meerdere regels code kunnen kopiëren en plakken op verschillende plekken in je programma. Maar die duplicatie zou je code laten groeien. In plaats daarvan kun je eenvoudig een functie definiëren om je strings te bewerken en die op de juiste plaatsen aanroepen. Zo stroomlijn je je code: compacter, beter leesbaar en sneller te typen.

def clean_string(string):
	exclude = set(string.punctuation + string.digits + " ")
    return ''.join(ch.lower() for ch in string if ch not in exclude)
 
my_string = "Hello, World! 123"
new_string = clean_string(my_string)
print(new_string)Mogelijk gemaakt door

Functies componeren om complexe datapijplijnen te bouwen

Functioneel programmeren is nuttig bij het werken met grote datasets of datapijplijnen omdat het ons in staat stelt complexe dataverwerkingstaken op te delen in kleinere, beter beheersbare stappen. Vaak wordt er voor elke stap in de pijplijn ten minste één functie gemaakt. Als je een stroomdiagram hebt uitgeschreven van de stappen die je in je pijplijn nodig hebt, heb je een ruwe indicatie van welke functies je nodig zult hebben. In grote lijnen heb je minimaal één functie per stap nodig.

De meeste talen hebben ook veel ingebouwde functies en downloadbare libraries met extra functies. Het purr-pakket in R is een goed voorbeeld. Dit maakt het makkelijker om snel een pijplijn te bouwen en het aantal eigen functies dat je moet schrijven te minimaliseren.

Expressieve en leesbare code creëren met FP-principes

Functioneel programmeren streeft naar zeer leesbare code. Enkele richtlijnen om expressieve en leesbare code te schrijven met functioneel programmeren:

• Houd functies klein en gefocust: Elke functie heeft één duidelijke verantwoordelijkheid, wat het begrijpen en onderhouden eenvoudiger maakt. Dit worden pure functies genoemd.
• Vermijd veranderlijke (muterende) staat: Vermijd het wijzigen van de staat van je data om neveneffecten te elimineren en de datastroom voorspelbaarder te maken. Onveranderlijke datastructuren dragen bij aan helderheid en redeneerbaarheid. Maak in plaats van een structuur te wijzigen een nieuwe datastructuur met de gewenste aanpassingen.
• Benut hogere-orde-functies: Functies die andere functies als argument nemen of functies teruggeven, heten hogere-orde-functies. Ze stellen je in staat expressievere en compactere code te schrijven.
• Gebruik functiecompositie: Functiecompositie is het combineren van twee of meer functies tot een nieuwe functie. Zo kun je complexe problemen opdelen in kleinere, beter beheersbare stukken.

Wat is objectgeoriënteerd programmeren (OOP)?

Objectgeoriënteerd programmeren is een paradigma dat de focus legt op objecten. Objecten zijn op zichzelf staande entiteiten die zowel data als methoden bevatten die op die data werken. Het is een manier om data en hun bewerkingen dicht bij elkaar te houden, in tegenstelling tot functioneel programmeren waar ze vaak gescheiden zijn. Dit kan het makkelijker maken om te volgen wat er met je data gebeurt.

In objectgeoriënteerd programmeren worden data en methoden georganiseerd in objecten die worden gedefinieerd door hun klasse. Klassen zijn ontworpen om te bepalen hoe elk object zich moet gedragen, en vervolgens worden objecten binnen die klasse ontworpen. Bekijk de DataCamp-tutorial voor meer details over hoe klassen in Python werken.

OOP-voorbeeld

Stel, je hebt een klasse BankAccount die beschrijft hoe elke rekening zich moet gedragen. Deze klasse kan attributen hebben zoals saldo, ID-nummer en klantnaam. Ook kan ze methoden hebben die beschrijven hoe informatie binnen die klasse kan worden beïnvloed, zoals opnemen, storten en saldo controleren.

Zodra deze klasse is gedefinieerd, kun je een object maken, in dit geval een rekening voor iemand. Nadat dit object is aangemaakt, kun je het vullen met de data voor elke eigenschap en de methoden gebruiken om de rekening te wijzigen. Zie het voorbeeld hieronder.

# Define a class representing a bank account
class BankAccount:
    def __init__(self, account_id, customer_name, initial_balance=0.0):
        # Initialize account properties
        self.account_id = account_id
        self.customer_name = customer_name
        self.balance = initial_balance

    # Method to deposit money into the account
    def deposit(self, amount):
        """Deposit money into the account."""
        if amount > 0:
            # Update balance and print deposit information
            self.balance += amount
            print(f"Deposited ${amount}. New balance: ${self.balance}")
        else:
            # Print message for invalid deposit amount
            print("Invalid deposit amount. Please deposit a positive amount.")

    # Method to withdraw money from the account
    def withdraw(self, amount):
        """Withdraw money from the account."""
        if 0 < amount <= self.balance:
            # Update balance and print withdrawal information
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")
        elif amount > self.balance:
            # Print message for insufficient funds
            print("Insufficient funds. Withdrawal canceled.")
        else:
            # Print message for invalid withdrawal amount
            print("Invalid withdrawal amount. Please withdraw a positive amount.")

    # Method to check the current balance of the account
    def check_balance(self):
        """Check the current balance of the account."""
        print(f"Current balance for {self.customer_name}'s account (ID: {self.account_id}): ${self.balance}")Mogelijk gemaakt door

Encapsulatie

Dit proces waarbij je data en gedrag bundelt in een object dat door een klasse is gedefinieerd, heet encapsulatie. Het stelt je in staat een duidelijke structuur te creëren waardoor de rest van de code eenvoudig met het object kan communiceren. De variabelen die binnen het object zijn opgeslagen, heten attributen, en de functies die het gedrag van het object bepalen, heten methoden.

Overerving

Een manier om code-duplicatie te verminderen is overerving gebruiken bij het maken van nieuwe klassen. Dit is een manier om nieuwe klassen te creëren die de functionaliteit van ouderklassen behouden. In ons bankrekeningvoorbeeld kun je een ouderklasse hebben die is veralgemeend voor alle rekeningen en kindklassen met specificaties voor spaarrekeningen en betaalrekeningen.

Polymorfie

Polymorfie is een concept dat je in staat stelt dezelfde naam te gebruiken voor verschillende methoden die ander gedrag hebben afhankelijk van de input. Dit wordt vaak gebruikt in combinatie met overerving.

Stel bijvoorbeeld dat we een ouderklasse Shape hebben met een methode om de oppervlakte van de vorm te berekenen. Je kunt twee kindklassen hebben, Circle en Square. Hoewel beide een methode met de naam Area zullen hebben, zal de definitie van die methode voor elke vorm anders zijn. Vergelijk de methoden voor oppervlakte voor de verschillende vormen in het onderstaande codeblok.

# Define the parent class Shape
class Shape:
	# Initialize the attributes for the shape
	def __init__(self, name):
    	    self.name = name
	
	# Define a generic method for calculating the area
	def area(self):
    	    print(f"The area of {self.name} is unknown.")
 
# Define the child class Circle that inherits from Shape
class Circle(Shape):
	# Initialize the attributes for the circle
	def __init__(self, name, radius):
    	# Call the parent class constructor
    	    super().__init__(name)
    	    self.radius = radius
	
	# Override the area method for the circle
	def area(self):
    	# Use the formula pi * r^2
    	    area = 3.14 * self.radius ** 2
    	    print(f"The area of {self.name} is {area}.")
 
# Define the child class Square that inherits from Shape
class Square(Shape):
	# Initialize the attributes for the square
	def __init__(self, name, side):
    	# Call the parent class constructor
    	    super().__init__(name)
    	    self.side = side
	
	# Override the area method for the square
	def area(self):
    	# Use the formula s^2
    	    area = self.side ** 2
    	    print(f"The area of {self.name} is {area}.")Mogelijk gemaakt door

Er zijn verschillende resources om objectgeoriënteerd programmeren te leren, waaronder DataCamp’s OOP in Python-cursus, OOP in R-cursus en OOP in Python-tutorial.

Voordelen van objectgeoriënteerd programmeren in data-analyse

Objectgeoriënteerd programmeren kan verschillende voordelen bieden voor data-analyse:

• Data-encapsulatie: Encapsulatie helpt de interne details van data-analyse-algoritmen en -structuren te verbergen en alleen de noodzakelijke interfaces bloot te leggen. Dit bevordert een duidelijke scheiding van componenten en verbetert de onderhoudbaarheid van code.
• Hergebruik van code: Objectgeoriënteerd programmeren stimuleert het maken van generieke klassen die door andere klassen kunnen worden overgeërfd, waardoor code-duplicatie wordt vermeden en de onderhoudsinspanning afneemt. Dit kan de productiviteit en efficiëntie van data-analyse verbeteren.
• Ontwerpvoordelen: Het modelleren van realistische problemen met klassen en objecten die data en gedrag vertegenwoordigen, verbetert de leesbaarheid, helderheid en modulariteit van data-analyse.

OOP vs. FP: het juiste paradigma kiezen

Er zijn veel factoren om te overwegen wanneer je OOP of FP voor je dataproject wilt gebruiken. Sommige datateams hebben een sterke voorkeur voor het ene paradigma boven het andere; in dat geval verdient het de voorkeur je paradigma af te stemmen op dat van je team. In andere gevallen kan de aard van je data of toepassingen de keuze in de ene of de andere richting doen uitvallen.

Wanneer OOP inzetten voor datataken

Objectgeoriënteerd programmeren is uitstekend voor toepassingen waarin je entiteiten moet modelleren. Goede voorbeelden zijn het ontwerpen van een systeem voor het beheren van een bibliotheek of het maken van een systeem om elk bedrijf in een beleggingsportefeuille te scoren. Het proces van het creëren van geïncapsuleerde objecten maakt het eenvoudig om deze entiteiten bij te houden. OOP heeft ook de voorkeur wanneer je beperkte geheugenruimte hebt, omdat FP doorgaans veel meer geheugen vereist dan OOP.

Wanneer FP inzetten voor datataken

Functioneel programmeren blinkt uit bij data-analysetaken die parallelle verwerking vereisen. De focus op onveranderlijkheid en het vermijden van neveneffecten maakt het eenvoudiger om bewerkingen op een dataset te paralleliseren. Functies kunnen gelijktijdig op verschillende delen van de data worden toegepast zonder elkaar te storen.

De focus van FP op onveranderlijkheid maakt het ook ideaal voor datatransformatiepijplijnen. Functies kunnen worden gecomponeerd om een reeks transformaties te creëren zonder status te muteren, wat leidt tot beter leesbare en beter onderhoudbare code.

FP heeft over het algemeen ook de voorkeur van wetenschappers en academici, omdat het dichter bij zuivere wiskunde blijft.

OOP- en FP-technieken combineren

In sommige praktische toepassingen kunnen OOP en FP in één programma worden gecombineerd. Zo kunnen developers de sterke punten van elk paradigma benutten. De encapsulatie van OOP en de expressiviteit van FP kunnen beide worden ingezet om een machinelearning-pijplijn of webapplicatie te bouwen.

Het combineren van paradigma’s kan echter uitdagingen met zich meebrengen en moet met zorg gebeuren. Code die tussen meerdere paradigma’s springt, kan moeilijker te doorgronden zijn. Ook kan het lastig zijn om een soepele integratie van de componenten te waarborgen.

Bekijk het onderstaande voorbeeld. Deze Python-code combineert OOP en FP om wiskundige bewerkingen uit te voeren op een lijst met getallen. De klasse MathOperation fungeert als een container voor een specifieke wiskundige operatie die met FP is gemaakt. De functies filter_odd_numbers en square_operation helpen respectievelijk oneven getallen filteren en het kwadraat van een getal berekenen. Door deze componenten samen te gebruiken, filtert de code efficiënt oneven getallen uit een gegeven lijst en kwadrateert ze vervolgens, wat laat zien hoe OOP en FP kunnen samenwerken om data-analysetaken te vereenvoudigen en te structureren.

# Object-Oriented Programming (OOP) - Class Definition
class MathOperation:
	def __init__(self, operation):
    	    self.operation = operation
 
	def apply_operation(self, number):
    	    return self.operation(number)
 
# Functional Programming (FP) - Higher-Order Functions
def filter_odd_numbers(numbers):
    return list(filter(lambda x: x % 2 != 0, numbers))
 
def square_operation(number):
    return number ** 2
 
def process_numbers(numbers, operation_function):
    return list(map(operation_function, numbers))
 
# Example Usage:
# Define an OOP class representing a mathematical operation (square in this case)
square_operation_instance = MathOperation(square_operation)
 
# Sample list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# Use FP to filter odd numbers
odd_numbers = filter_odd_numbers(numbers)
 
# Use OOP to apply the square operation to odd numbers
result = process_numbers(odd_numbers, square_operation_instance.apply_operation)
 
# Display the result
print(result)Mogelijk gemaakt door

Voor nog een voorbeeld van het combineren van OOP en FP, bekijk deze github-repository.

Conclusie

Er is geen definitief antwoord op de vraag welk programmeerparadigma de beste keuze is; dat hangt af van de context, het doel, de taal en de voorkeur van de programmeur. Er zijn echter wel enkele algemene richtlijnen die je kunt volgen om te bepalen welk paradigma het beste werkt voor jouw situatie.

Gebruik OOP wanneer je complexe systemen met meerdere entiteiten en interacties moet modelleren, en wanneer je data en gedrag wilt inkapselen in herbruikbare componenten. Gebruik FP wanneer je pure berekeningen moet uitvoeren met eenvoudige inputs en outputs, en wanneer je neveneffecten of statuswijzigingen wilt vermijden. Gebruik een gemengde aanpak wanneer je de sterke punten van beide paradigma’s wilt benutten en wanneer je je moet aanpassen aan de mogelijkheden en beperkingen van de taal.

De beste programmeurs zijn niet beperkt tot het ene of het andere paradigma; ze kunnen tussen paradigma’s schakelen wanneer dat nodig is om hun doelen te bereiken. Verken een reeks paradigma’s in detail met de cursus Introduction to Programming Paradigms. Ga aan de slag met een dataproject en gebruik zowel OOP als FP om het project op te lossen. Door elk paradigma te oefenen, ontwikkel je een goed gevoel voor wat het beste werkt voor jouw project.