Incapsulamento in Python

L’incapsulamento è un altro concetto chiave nella programmazione orientata agli oggetti che consente di nascondere i dettagli di implementazione di una classe e di proteggere i dati da accessi non autorizzati. 

In Python, l’incapsulamento è principalmente ottenuto utilizzando il prefisso doppio sottolineato ( __ ) prima del nome degli attributi o dei metodi di una classe, ecco un esempio:

class ContoBancario:
    def __init__(self, nome_titolare, saldo_iniziale):
        self.__nome_titolare = nome_titolare
        self.__saldo = saldo_iniziale
    # Getter per ottenere il nome del titolare del conto
    def get_nome_titolare(self):
        return self.__nome_titolare
    # Setter per impostare il nome del titolare del conto
    def set_nome_titolare(self, nuovo_nome):
        self.__nome_titolare = nuovo_nome
    # Getter per ottenere il saldo del conto
    def get_saldo(self):
        return self.__saldo
    # Setter per depositare una certa quantità di denaro nel conto
    def deposita(self, importo):
        if importo > 0:
            self.__saldo += importo
            print("Deposito effettuato: +”, importo, “EUR")
        else:
            print("L'importo del deposito deve essere maggiore di zero.")
    # Setter per prelevare una certa quantità di denaro dal conto
    def preleva(self, importo):
        if importo > 0 and importo <= self.__saldo:
            self.__saldo -= importo
            print("Prelievo effettuato: -”, importo, “EUR")
        elif importo <= 0:
            print("L'importo del prelievo deve essere maggiore di zero.")
        else:
            print("Fondi insufficienti per il prelievo.")
# Creiamo un conto bancario
conto = ContoBancario("Mario Rossi", 1000)
# Utilizziamo i getter per ottenere le informazioni
print("Titolare del conto:”, conto.get_nome_titolare())
print("Saldo iniziale:”, conto.get_saldo(), ” EUR")
# Utilizziamo i setter per effettuare operazioni sul conto
conto.deposita(500)
conto.preleva(200)
# Stampiamo il saldo aggiornato
print("Saldo attuale:”, conto.get_saldo(), ” EUR")

Funzionamento pratico dell’incapsulamento in Python

Descriviamo ora il funzionamento pratico dell’incapsulamento in Python, inerentemente ad attributi privati, metodi privati e metodi pubblici.

1. Attributi Privati :
   
   Gli attributi di una classe possono essere dichiarati come privati mettendo __ prima del loro nome.  Ad esempio, __nome indica un attributo privato.

   class Persona:
       def __init__(self, nome, cognome):
           self.__nome = nome
           self.__cognome = cognome

   Non è possibile accedere direttamente dall’esterno della classe agli attributi privati. Tentativi di accesso a tali attributi causeranno un errore. Questo aiuta a garantire che i dati siano modificati solo attraverso metodi specifici della classe.

2. Metodi Privati: Analogamente, i metodi di una classe possono essere dichiarati come privati utilizzando il prefisso __.  Ad esempio, __calcola_eta indica un metodo privato.

   class Persona:
       def __init__(self, nome, cognome):
           self.__nome = nome
           self.__cognome = cognome
       def __calcola_eta(self, anno_di_nascita):
           # Questo è un metodo privato per calcolare l'età
           return 2023 - anno_di_nascita

   I metodi privati non possono essere chiamati direttamente dall’esterno della classe. Questo è utile per nascondere la logica interna e le implementazioni dei metodi.

3. Metodi Pubblici: Per consentire agli utenti esterni di interagire con gli attributi privati o di eseguire operazioni specifiche, è possibile creare metodi pubblici nella classe.

   class Persona:
       def __init__(self, nome, cognome):
           self.__nome = nome
           self.__cognome = cognome
       def calcola_eta(self, anno_di_nascita):
           # Questo è un metodo pubblico per calcolare l'età
           return 2023 - anno_di_nascita

   
   I metodi pubblici possono essere chiamati dall’esterno della classe e sono il modo principale attraverso cui gli utenti interagiscono con gli oggetti di quella classe.

L’incapsulamento in Python è importante perché offre una protezione dei dati e una separazione tra l’implementazione interna di una classe e l’uso esterno. Ciò rende il codice più robusto, più facile da manutenere e migliora la modularità. Gli attributi privati e i metodi privati sono accessibili solo all’interno della classe stessa, il che significa che gli errori di programmazione sono meno probabili e che è possibile modificare l’implementazione interna senza influenzare il codice esterno che utilizza la classe.

Ecco un esempio di utilizzo dell’incapsulamento in Python:

persona = Persona("Alice", "Smith")
# Questo genererà un errore perché __nome è un attributo privato.
print(persona.__nome)
# Questo funzionerà poiché stiamo utilizzando un metodo pubblico.
eta = persona.calcola_eta(1990)
print(eta)

In breve, l’incapsulamento è uno dei principi fondamentali della OOP che aiuta a creare classi più sicure e modulari, migliorando la manutenibilità del codice.