Fondamenti di Python

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.

  • Principiante
  • 4 min di lettura
  • 1 esempio eseguibile

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

Dalla banca al codice
self._balance🔒 I soldi dietro lo sportello: cambiali solo tramite deposit()
class SavingsAccount(BankAccount):🏦 Un conto di risparmio è un conto, più gli interessi
super().__init__(owner, balance)📋 Compila prima il modulo del conto normale
account.month_end()📅 Fine mese per tutti: ogni conto fa la sua versione
Regole comuni nella classe base, differenze nella sottoclasse.
In una frase

La 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

  1. BankAccount possiede il saldo e valida i depositi.
  2. SavingsAccount riutilizza il contratto di base.
  3. SavingsAccount ridefinisce month_end per applicare gli interessi.
  4. Il ciclo usa tutti i conti tramite la stessa interfaccia.
Suggerimento: Preferisci la composizione quando un oggetto ne usa un altro; usa l’ereditarietà solo con sostituzione corretta.

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

Esegui codice →
main.py
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})")
Crea un pulsante Run per questo esempio

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

Esegui codice →

riunire stato e comportamento e controllarne l’accesso.

encapsulation.py
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

Esegui codice →

mostrare un’interfaccia utile nascondendo i dettagli superflui.

abstraction.py
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à

Esegui codice →

specializzare una classe solo per una vera relazione is-a.

inheritance.py
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

Esegui codice →

usare la stessa operazione con oggetti diversi e comportamento appropriato.

polymorphism.py
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.

  1. Cambia i dati di input e prova a prevedere il risultato prima di eseguire.
  2. Aggiungi un controllo per i dati vuoti o non validi.
  3. Sposta la logica in una funzione separata e provala con diversi insiemi di dati.
Esegui nel compilatore Python →

Errori comuni

Dimenticare di chiamare super().__init__

Senza questa chiamata, l'inizializzazione della classe genitore non parte e mancano attributi come owner.

Problema
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Correzione
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().

Problema
account._balance = -500
Correzione
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