Programmazione funzionale vs programmazione orientata agli oggetti nell’analisi dei dati

Una buona struttura è il segno distintivo di un codice ben scritto. La natura di questa struttura è determinata dal paradigma di programmazione utilizzato. Un paradigma di programmazione è un insieme coerente di principi e tecniche che definisce l’approccio adottato nella progettazione e scrittura dei programmi.

Esistono molti paradigmi di programmazione, come quello procedurale, imperativo, dichiarativo, orientato agli oggetti e funzionale. Alcuni linguaggi sono limitati a pochi paradigmi. Per esempio, SQL è un linguaggio dichiarativo. Tuttavia, molti linguaggi moderni, tra cui Python, supportano diversi paradigmi di programmazione, offrendo così flessibilità.

Esercitati a scrivere funzioni pure con un esercizio pratico dal nostro corso Introduction to Programming Paradigms. 

Molti programmatori si affidano a un paradigma preferito, spesso quello che hanno imparato per primo. I programmatori più esperti comprendono vantaggi e limiti di questi paradigmi e sanno sfruttarne i punti di forza in scenari diversi. Vediamo due dei paradigmi di programmazione più usati nella data science: la programmazione funzionale e la programmazione orientata agli oggetti.

Che cos’è la programmazione funzionale (FP)?

Nella programmazione funzionale, il codice è costruito definendo e usando funzioni che stabiliscono come il programma deve operare. È un sottoinsieme del paradigma di programmazione dichiarativa.

Le funzioni sono porzioni di codice che prendono argomenti in ingresso e restituiscono risultati. Una funzione semplice può, per esempio, prendere una lista di numeri come argomento e restituire solo i valori pari.

def get_even_numbers(list):
    return [num for num in list if num % 2 == 0]Offerto da

Dai un’occhiata a questi corsi per imparare le best practice per scrivere funzioni in Python e in R.

La programmazione funzionale si distingue per tracciabilità e prevedibilità. Questo perché le funzioni utilizzate sono immutabili, cioè non possono essere modificate. Le funzioni vengono definite, spesso in una sezione separata del codice (o talvolta in un file diverso), e poi usate nel resto del codice secondo necessità. Questo rende facile capire cosa succede in una sezione di codice, perché la funzione si comporta e viene chiamata sempre allo stesso modo ovunque.

Il concetto di immutabilità si estende anche alle strutture dati nella programmazione funzionale. In FP, quando si cambia lo stato dei dati, è preferibile crearne una copia. Questo stabilisce una sorta di traccia cartacea virtuale di tutte le trasformazioni applicate ai dati, migliorando la tracciabilità e semplificando l’individuazione dei problemi. È però importante notare che questo approccio comporta spesso un maggior consumo di memoria, poiché ogni modifica di stato implica la copia dell’intero dataset.

Un sottoinsieme di funzioni utilizzate nella programmazione funzionale sono le funzioni di ordine superiore. Sono funzioni che prendono un’altra funzione come argomento o restituiscono una funzione come risultato. Per esempio, puoi avere una funzione di ordine superiore che esegue una funzione più volte, come quella mostrata sotto, o una che sceglie la funzione giusta da usare in uno scenario specifico.

def run_function_multiple_times(function, num_times):
	for i in range(num_times):
        function()Offerto da

Vantaggi della programmazione funzionale nell’analisi dei dati

La programmazione funzionale offre una struttura per ridurre le duplicazioni nel codice. L’obiettivo è rendere facile esprimere azioni ripetute usando verbi ad alto livello.

Per esempio, supponi di dover modificare stringhe per adattarle a un formato particolare in vari punti del tuo codice. Questo formato richiede di rimuovere spazi, punteggiatura e numeri e di mettere tutto in minuscolo. Potresti copiare e incollare diverse righe di codice in parti diverse del programma quando necessario. Ma questa duplicazione gonfierebbe il tuo codice. Invece, puoi definire una funzione per modificare le stringhe e chiamarla nei punti opportuni. In questo modo snellisci il codice rendendolo più compatto, leggibile e veloce da scrivere.

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)Offerto da

Comporre funzioni per creare pipeline di dati complesse

La programmazione funzionale è utile quando si lavora con grandi dataset o pipeline di dati, perché permette di suddividere compiti di elaborazione complessi in passaggi più piccoli e gestibili. Spesso, viene creata almeno una funzione per ogni passaggio della pipeline. Se hai disegnato un diagramma di flusso dei passaggi necessari nella pipeline, avrai un’idea approssimativa delle funzioni necessarie. In generale, servirà almeno una funzione per ciascun passaggio.

La maggior parte dei linguaggi offre molte funzioni integrate e librerie aggiuntive scaricabili. Il pacchetto purrr in R è un ottimo esempio. Questo rende più semplice costruire rapidamente una pipeline riducendo al minimo il numero di funzioni personalizzate da creare.

Creare codice espressivo e leggibile usando i principi FP

La programmazione funzionale punta a un codice molto leggibile. Ecco alcune linee guida per costruire codice espressivo e leggibile usando la programmazione funzionale:

• Tieni le funzioni piccole e mirate: ogni funzione dovrebbe avere una responsabilità chiara e unica, così da essere più facile da capire e mantenere. Queste sono chiamate funzioni pure.
• Evita lo stato mutabile (variabile): evita di cambiare lo stato dei tuoi dati per eliminare effetti collaterali e rendere il flusso dei dati più prevedibile. Le strutture dati immutabili contribuiscono alla chiarezza del codice e al ragionamento. Invece di modificare lo stato di una struttura, crea una nuova struttura dati con le modifiche desiderate.
• Sfrutta le funzioni di ordine superiore: le funzioni che accettano altre funzioni come argomenti o restituiscono funzioni sono chiamate funzioni di ordine superiore. Ti permettono di scrivere codice più espressivo e conciso.
• Usa la composizione di funzioni: la composizione è il processo di combinare due o più funzioni per produrne una nuova. Questo ti consente di scomporre problemi complessi in parti più piccole e gestibili.

Che cos’è la programmazione orientata agli oggetti (OOP)?

La programmazione orientata agli oggetti è un paradigma che si concentra sugli oggetti. Gli oggetti sono entità autonome che comprendono sia dati sia metodi che operano su quei dati. È un modo per mantenere vicini dati e operazioni, a differenza della programmazione funzionale, dove spesso sono separati. Questo può rendere più facile seguire cosa sta succedendo ai tuoi dati.

Nella programmazione orientata agli oggetti, dati e metodi sono organizzati in oggetti definiti dalla loro classe. Le classi sono progettate per stabilire come ciascun oggetto dovrebbe comportarsi, e poi gli oggetti vengono creati all’interno di quella classe. Dai un’occhiata al tutorial di DataCamp per ulteriori dettagli su come funzionano le classi in Python.

Esempio OOP

Per esempio, potresti avere una classe chiamata BankAccount che descrive come dovrebbe comportarsi ogni conto. Questa classe può avere attributi come saldo, numero ID e nome del cliente. Può anche avere metodi che descrivono come possono essere modificati i dati all’interno della classe, come prelievo, deposito e controllo del saldo.

Una volta definita la classe, puoi creare un oggetto, in questo caso un conto per qualcuno. Dopo aver creato l’oggetto, puoi popolarlo con i dati di ciascuna proprietà e usare i metodi per modificare il conto. Vedi l’esempio sotto.

# 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}")Offerto da

Incapsulamento

Questo processo di raggruppare dati e comportamento in un oggetto definito da una classe si chiama incapsulamento. Ti consente di creare una struttura ben definita che permette al resto del codice di interagire facilmente con l’oggetto. Le variabili memorizzate all’interno dell’oggetto si chiamano attributi, e le funzioni che determinano il comportamento dell’oggetto si chiamano metodi.

Ereditarietà

Un modo per ridurre la duplicazione del codice è usare l’ereditarietà quando si creano nuove classi. È un modo di creare nuove classi che mantengono la funzionalità delle classi genitrici. Nel nostro esempio del conto bancario, potresti avere una classe genitore generalizzata per tutti i conti e classi figlie con specifiche per conti di risparmio e conti correnti.

Polimorfismo

Il polimorfismo è un concetto che permette di usare lo stesso nome per metodi diversi che hanno comportamenti differenti a seconda dell’input. È comunemente usato insieme all’ereditarietà.

Per esempio, supponiamo di avere una classe genitore chiamata Shape che ha un metodo per calcolare l’area della forma. Potresti avere due classi figlie, Circle e Square. Sebbene entrambe abbiano il metodo chiamato Area, la definizione di quel metodo sarà diversa per ciascuna forma. Confronta i metodi per l’area delle diverse forme nel blocco di codice seguente.

# 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}.")Offerto da

Esistono diverse risorse per imparare a usare la programmazione orientata agli oggetti, tra cui il corso OOP in Python di DataCamp, il corso OOP in R e il tutorial OOP in Python.

Vantaggi della programmazione orientata agli oggetti nell’analisi dei dati

La programmazione orientata agli oggetti può offrire diversi vantaggi all’analisi dei dati:

• Incapsulamento dei dati: l’incapsulamento aiuta a nascondere i dettagli interni di algoritmi e strutture per l’analisi dei dati, esponendo solo le interfacce necessarie. Questo favorisce una chiara separazione dei componenti e migliora la manutenibilità del codice.
• Riutilizzo del codice: la programmazione orientata agli oggetti incoraggia la creazione di classi generiche che possono essere ereditate da altre classi, evitando la duplicazione del codice e riducendo lo sforzo di manutenzione. Questo può migliorare produttività ed efficienza dell’analisi dei dati.
• Benefici di design: la modellazione di problemi reali usando classi e oggetti che rappresentano dati e comportamenti migliora leggibilità, chiarezza e modularità dell’analisi dei dati.

OOP vs FP: scegliere il paradigma giusto

Ci sono molti fattori da considerare quando si sceglie se usare OOP o FP per un progetto di dati. Alcuni team dati possono preferire nettamente un paradigma rispetto all’altro; in tal caso, è meglio allineare il tuo paradigma a quello del team. In altri casi, la natura dei tuoi dati o delle applicazioni può far pendere l’ago della bilancia da una parte o dall’altra.

Quando sfruttare OOP per compiti sui dati

La programmazione orientata agli oggetti è eccellente per applicazioni in cui devi modellare entità. Ottimi esempi includono progettare un sistema per gestire una biblioteca o creare un sistema per valutare ogni azienda in un portafoglio di investimento. Il processo di creazione di oggetti incapsulati rende facile tenere traccia di queste entità. OOP è anche preferita quando hai memoria limitata, poiché FP tende a richiedere molta più memoria rispetto a OOP.

Quando sfruttare FP per compiti sui dati

La programmazione funzionale eccelle nei compiti di analisi dei dati che richiedono elaborazione parallela. L’attenzione all’immutabilità e all’eliminazione degli effetti collaterali rende più facile parallelizzare le operazioni su un dataset. Le funzioni possono essere applicate in modo concorrente su parti diverse dei dati senza interferenze.

Il focus di FP sull’immutabilità la rende anche ideale per pipeline di trasformazione dei dati. Le funzioni possono essere composte per creare una serie di trasformazioni senza mutare lo stato, con un codice più leggibile e manutenibile.

FP è anche generalmente preferita da scienziati e accademici perché mantiene un’impostazione più vicina alla matematica pura.

Combinare le tecniche OOP e FP

In alcune applicazioni pratiche, OOP e FP possono essere combinate in un programma. Questo consente agli sviluppatori di sfruttare i punti di forza di ciascun paradigma. L’incapsulamento di OOP e l’espressività di FP possono essere entrambi sfruttati per costruire una pipeline di machine learning o un’applicazione web.

Tuttavia, combinare paradigmi in questo modo può presentare sfide e va fatto con cautela. Può essere più difficile decifrare codice che passa tra più paradigmi. Può anche essere impegnativo garantire un’integrazione fluida dei componenti.

Considera l’esempio seguente. Questo codice Python combina OOP e FP per eseguire operazioni matematiche su una lista di numeri. La classe MathOperation funge da contenitore per una specifica operazione matematica creata usando FP. Le funzioni filter_odd_numbers e square_operation aiutano rispettivamente a filtrare i numeri dispari e a calcolare il quadrato di un numero. Usando insieme questi componenti, il codice filtra in modo efficiente i numeri dispari da una lista e poi li eleva al quadrato, mostrando come OOP e FP possano collaborare per semplificare e organizzare i compiti di analisi dei dati.

# 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)Offerto da

Per un altro esempio di uso combinato di OOP e FP, dai un’occhiata a questo repository GitHub.

Conclusione

Non esiste una risposta definitiva su quale paradigma di programmazione sia la scelta migliore: dipende dal contesto, dall’obiettivo, dal linguaggio e dalle preferenze del programmatore. Tuttavia, ci sono alcune linee guida generali che puoi seguire per capire quale paradigma funzionerà meglio per la tua situazione.

Usa OOP quando devi modellare sistemi complessi con più entità e interazioni, e quando hai bisogno di incapsulare dati e comportamento in componenti riutilizzabili. Usa FP quando devi eseguire calcoli puri con input e output semplici e quando devi evitare effetti collaterali o cambiamenti di stato. Usa un approccio misto quando vuoi sfruttare i punti di forza di entrambi i paradigmi e quando devi adattarti alle caratteristiche e ai limiti del linguaggio.

I programmatori migliori non si limitano a un paradigma o all’altro; sanno passare da un paradigma all’altro secondo necessità per raggiungere i propri obiettivi. Esplora a fondo una gamma di paradigmi con il corso Introduction to Programming Paradigms. Prova a lavorare a un progetto sui dati e usa sia OOP sia FP per risolverlo. Fare pratica con ciascun paradigma ti darà una buona intuizione su quale funzionerà meglio per il tuo progetto.