La programmazione orientata agli oggetti in Python
In questa lezione conoscerai incapsulamento, ereditarietà, override dei metodi e polimorfismo con un esempio di conto bancario in Python.
Cos’è la programmazione orientata agli oggetti in Python?
Il problema
Quando un programma cresce, molte parti hanno bisogno degli stessi tipi di oggetti con piccole differenze: un conto normale e un conto di risparmio, un gatto e un cane. Copiare le classi e cambiare qualche riga porta a codice duplicato, e se controlli il tipo con if ovunque, aggiungere un nuovo tipo diventa un lavoro enorme.
Immaginalo così
La programmazione a oggetti funziona come i conti correnti di una stessa banca. Ogni conto tiene il suo saldo dietro lo sportello (incapsulamento). Un conto di risparmio è un conto normale con una funzione in più (ereditarietà). Quando la banca annuncia a tutti i conti che è fine mese, ognuno fa la sua versione (polimorfismo).
self._balance🔒 I soldi dietro lo sportello: cambiali solo tramite deposit()class SavingsAccount(BankAccount):🏦 Un conto di risparmio è un conto, più gli interessisuper().__init__(owner, balance)📋 Compila prima il modulo del conto normaleaccount.month_end()📅 Fine mese per tutti: ogni conto fa la sua versioneLa programmazione orientata agli oggetti organizza un programma in classi i cui oggetti tengono privati i loro dati (incapsulamento), riusano altre classi (ereditarietà) e rispondono alla stessa chiamata a modo loro (polimorfismo).
La OOP modella un sistema come oggetti che collaborano. Ogni oggetto unisce stato e operazioni consentite, chiarendo le responsabilità nelle applicazioni grandi.
I quattro principi fondamentali
- Incapsulamento: riunire stato e comportamento e controllarne l’accesso.
- Astrazione: mostrare un’interfaccia utile nascondendo i dettagli superflui.
- Ereditarietà: specializzare una classe solo per una vera relazione is-a.
- Polimorfismo: usare la stessa operazione con oggetti diversi e comportamento appropriato.
Progettazione dell’esempio
- BankAccount possiede il saldo e valida i depositi.
- SavingsAccount riutilizza il contratto di base.
- SavingsAccount ridefinisce month_end per applicare gli interessi.
- Il ciclo usa tutti i conti tramite la stessa interfaccia.
Quando si usa?
- Più tipi di oggetti che condividono la maggior parte del comportamento: tipi di conto, forme, personaggi di gioco.
- Codice che dovrà funzionare con nuovi tipi in futuro senza essere riscritto.
- Proteggere dati che devono restare validi, come un saldo che non può mai essere negativo.
Quando non serve
- Piccoli script con poche funzioni: classi ed ereditarietà aggiungono una struttura che non ti serve.
- Catene di ereditarietà profonde (A da B da C da D): sono difficili da seguire, meglio la composizione.
Esempio di base
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = float(balance)
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self._balance += amount
def month_end(self):
return "No interest"
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, interest_rate):
super().__init__(owner, balance)
self.interest_rate = interest_rate
def month_end(self):
self._balance *= 1 + self.interest_rate
return "Interest applied"
accounts = [
BankAccount("Ada", 100),
SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)
for account in accounts:
status = account.month_end()
print(f"{account.owner}: {account.balance:.2f} ({status})")
Risultato dell'esecuzione
Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)
I quattro principi OOP in pratica
Questi esempi mirati mostrano come Python applica incapsulamento, astrazione, ereditarietà e polimorfismo nel codice quotidiano.
Incapsulamento
riunire stato e comportamento e controllarne l’accesso.
class BankAccount:
def __init__(self, balance=0):
# Double underscores prevent accidental direct access.
self.__balance = balance
@property
def balance(self):
# Expose read access without exposing mutation.
return self.__balance
def deposit(self, amount):
# Keep validation next to the state it protects.
if amount <= 0:
raise ValueError("Amount must be positive")
self.__balance += amount
account = BankAccount(100)
account.deposit(50)
print(account.balance) # 150
Astrazione
mostrare un’interfaccia utile nascondendo i dettagli superflui.
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
# Callers know what pay does, not how each provider does it.
pass
class CreditCard(PaymentMethod):
def pay(self, amount):
# The concrete class hides its payment implementation.
return f"Paid ${amount:.2f} by card"
payment = CreditCard()
print(payment.pay(25))
Ereditarietà
specializzare una classe solo per una vera relazione is-a.
class Employee:
def __init__(self, name):
self.name = name
def describe(self):
return self.name
class Developer(Employee):
def __init__(self, name, language):
# Reuse initialization from the parent class.
super().__init__(name)
self.language = language
def describe(self):
# Extend inherited behavior instead of duplicating it.
return f"{super().describe()} writes {self.language}"
print(Developer("Ada", "Python").describe())
Polimorfismo
usare la stessa operazione con oggetti diversi e comportamento appropriato.
class EmailNotification:
def send(self, message):
return f"Email: {message}"
class SmsNotification:
def send(self, message):
return f"SMS: {message}"
def notify(channels, message):
for channel in channels:
# The same call selects behavior from each concrete object.
print(channel.send(message))
channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")
Spiegazione del codice
La classe BankAccount incapsula il saldo nell'attributo _balance e permette di modificarlo solo tramite metodi con controlli, come deposit(). La classe SavingsAccount eredita tutti questi metodi e fa l'override di month_end() per aggiungere gli interessi. Il ciclo chiama lo stesso metodo su entrambi i conti, ma Python sceglie durante l'esecuzione la versione adatta a ciascun tipo di oggetto. Questo è il polimorfismo.
Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.
Esercizi di approfondimento
Prova a modificare il codice seguendo i suggerimenti qui sotto. Cambiare il codice e osservare il risultato ti aiuta a capire molto più che leggerlo soltanto.
- Cambia i dati di input e prova a prevedere il risultato prima di eseguire.
- Aggiungi un controllo per i dati vuoti o non validi.
- Sposta la logica in una funzione separata e provala con diversi insiemi di dati.
Errori comuni
Dimenticare di chiamare super().__init__
Senza questa chiamata, l'inizializzazione della classe genitore non parte e mancano attributi come owner.
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
self.interest_rate = rate
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
super().__init__(owner, balance)
self.interest_rate = rate
Cambiare direttamente i dati protetti
Impostare _balance da fuori salta i controlli di deposit().
account._balance = -500
account.deposit(50)
Hai finito questa lezione?
Segnala come imparata per tenere traccia dei tuoi progressi.
Esercitati con una sfida
Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.
Tutte le sfide