Python OOP: classi, oggetti, ereditarietà e polimorfismo

Python: classi, oggetti, incapsulamento, ereditarietà e polimorfismo

MEGISTONE · Informatica · Seconda Scienze Applicate · B1.08 · Articolo 16/55

La programmazione orientata agli oggetti Python (OOP, Object-Oriented Programming) è un modo per strutturare il software attorno a entità dotate di stato e comportamento. Dopo aver imparato a scrivere funzioni, elaborare collezioni, gestire file e dialogare con database, impariamo a costruire sistemi in cui ciascun componente ha una responsabilità riconoscibile. Il filo conduttore sarà un laboratorio scientifico che acquisisce e analizza misure.

Prerequisiti: variabili, tipi, funzioni, eccezioni, liste, dizionari, moduli. Obiettivi verificabili: creare classi e istanze, progettare interfacce pubbliche, validare lo stato, spiegare l’ereditarietà e il polimorfismo, scegliere la composizione quando appropriato, testare un programma a oggetti. Ambiente: Python 3.13 e libreria standard; gli esempi non richiedono database né hardware. Raccordo curricolare: area algoritmi e linguaggi (AL), astrazione e risoluzione di problemi; l’approfondimento a oggetti anticipa temi che torneranno nel secondo biennio. Perimetro: niente GUI, UML avanzato, framework o distribuzione di applicazioni.

16.1 — Dalla programmazione procedurale agli oggetti

Nella programmazione procedurale il programma è organizzato in istruzioni e funzioni. È un modello efficace per problemi lineari, algoritmi e trasformazioni di dati. Possiamo rappresentare un sensore come un dizionario e fornire a una funzione il suo stato. Ma quando il sistema contiene molte entità, ogni funzione deve conoscere la struttura dei dizionari; modifiche ai nomi delle chiavi possono propagarsi in più punti.

# Soluzione procedurale: dati e operazioni distinti.
sensore = {"codice": "T1", "temperatura": 21.5}

def leggi_temperatura(dati):
    return dati["temperatura"]

print(leggi_temperatura(sensore))  # 21.5

Nella OOP riuniamo un modello dei dati e le operazioni pertinenti in un oggetto. Una classe descrive quali attributi e metodi potranno avere i suoi oggetti. Lo stato corrisponde ai valori conservati; il comportamento alle operazioni disponibili. L’astrazione seleziona i dettagli significativi e nasconde quelli accidentali. Il vantaggio non è soltanto scrivere meno righe: è delimitare le responsabilità, favorire il riuso e rendere più esplicite le regole del dominio.

class Termometro:
    def __init__(self, codice, temperatura):
        self.codice = codice
        self.temperatura = temperatura

    def leggi(self):
        return self.temperatura

sensore = Termometro("T1", 21.5)
print(sensore.leggi())  # 21.5

L’OOP non è sempre la soluzione migliore: una singola funzione che converte gradi Celsius in kelvin è spesso più semplice di una gerarchia di classi. Si sceglie il modello in base al problema, alla leggibilità e alla manutenzione.

16.2 — Che cos’è una classe

La parola chiave class introduce una nuova definizione di tipo. Dopo il nome e i due punti, un blocco indentato contiene attributi e metodi. PEP 8 suggerisce nomi di classe in CapWords (ad esempio MisuraScientifica), nomi di metodi e variabili in snake_case, quattro spazi per livello d’indentazione e nomi esplicativi.

class Misura:
    """Modella una grandezza e la relativa unità."""
    def __init__(self, valore, unita):
        self.valore = valore
        self.unita = unita

    def descrivi(self):
        return f"{self.valore:.2f} {self.unita}"

m = Misura(12.34, "V")
print(m.descrivi())  # 12.34 V

Misura è il modello; m è un’istanza specifica. Gli attributi valore e unita custodiscono dati; il metodo descrivi() produce un risultato. Nel progetto reale bisognerà anche validare il tipo e il campo di valori, perché creare una classe non rende automaticamente validi i dati.

16.3 — Oggetti e istanze

La chiamata Misura(…) produce un’istanza. Ogni oggetto conserva uno stato ed è raggiungibile tramite uno o più riferimenti. Due variabili possono indicare lo stesso oggetto; in quel caso una modifica effettuata tramite una variabile si osserva anche tramite l’altra. Al contrario, due istanze create separatamente possono avere stati uguali pur essendo identità diverse.

class Misura:
    def __init__(self, valore):
        self.valore = valore

a = Misura(10)
b = Misura(10)
c = a
print(a is b)  # False: identità diversa
print(a is c)  # True: stesso oggetto
c.valore = 13
print(a.valore, b.valore)  # 13 10

is confronta l’identità; == applica il criterio di uguaglianza del tipo. Nelle classi semplici definite dall’utente, se non si definisce l’uguaglianza, == usa il comportamento ereditato da object e coincide di norma con l’identità. Non usare is per confrontare valori numerici o stringhe; serve a verificare l’identità o il caso speciale is None.

16.4 — Il metodo __init__() e l’inizializzazione

__init__() viene chiamato quando una nuova istanza deve essere inizializzata. Il primo parametro dei metodi d’istanza è convenzionalmente self: indica l’oggetto su cui opera il metodo. Python lo passa automaticamente quando scriviamo oggetto.metodo(). Con self.nome = ... attribuiamo dati a quell’istanza. __init__ non crea tecnicamente l’oggetto: per la creazione interviene __new__, che qui non serve personalizzare.

class Misura:
    def __init__(self, valore, unita="m"):
        if not isinstance(valore, (int, float)) or isinstance(valore, bool):
            raise TypeError("Valore numerico richiesto")
        self.valore = float(valore)
        self.unita = unita

    def descrivi(self):
        return f"{self.valore:.2f} {self.unita}"

print(Misura(2.5).descrivi())  # 2.50 m
print(Misura(7, "kg").descrivi())  # 7.00 kg

Un parametro mancante genera spesso TypeError; dimenticare self nella firma di un metodo può produrre un errore sul numero degli argomenti; omettere self. nella scrittura di un attributo crea invece una variabile locale e lascia lo stato incompleto. I controlli iniziali devono proteggere le invarianti, ossia le condizioni che devono rimanere vere durante la vita dell’oggetto.

16.5 — Attributi di istanza e attributi di classe

Gli attributi scritti su self sono normalmente diversi per ogni istanza. Gli attributi definiti direttamente nel corpo della classe appartengono alla classe e sono condivisi nella ricerca degli attributi. In assenza di un attributo sull’istanza, Python può cercarlo nella classe. Assegnare oggetto.attributo = ... crea spesso un attributo sull’istanza che nasconde quello di classe, senza modificarlo.

class Strumento:
    creati = 0

    def __init__(self, codice):
        self.codice = codice
        type(self).creati += 1

x = Strumento("A")
y = Strumento("B")
print(Strumento.creati)  # 2
print(x.codice, y.codice)  # A B

Il contatore qui funziona per la sola classe Strumento; in una gerarchia di sottoclassi type(self).creati += 1 potrebbe creare contatori distinti per classe. Occorre decidere quale comportamento si desidera.

Errore classico: lista mutabile condivisa.

class Sbagliato:
    misure = []  # condivisa da tutte le istanze!

x = Sbagliato()
y = Sbagliato()
x.misure.append(5)
print(y.misure)  # [5]

class Corretto:
    def __init__(self):
        self.misure = []  # una lista nuova per ogni istanza

x = Corretto()
y = Corretto()
x.misure.append(5)
print(y.misure)  # []

16.6 — Metodi di istanza e comportamento degli oggetti

Un metodo d’istanza può leggere lo stato, calcolare un risultato o modificare lo stato. È utile separare questi compiti e restituire valori invece di stampare sempre direttamente a schermo: così il programma è più facile da testare, riusare e collegare a un’interfaccia.

from statistics import mean

class SensoreTemperatura:
    def __init__(self, codice):
        self.codice = codice
        self._misure = []

    def registra(self, temperatura):
        valore = float(temperatura)
        if valore < -273.15:
            raise ValueError("Sotto lo zero assoluto")
        self._misure.append(valore)

    def media(self):
        return mean(self._misure) if self._misure else None

s = SensoreTemperatura("T1")
s.registra(20)
s.registra(22)
print(s.media())  # 21.0

La media del contenitore vuoto non è definita. Qui scegliamo di restituire None; in altri progetti può essere opportuno sollevare un’eccezione. È una decisione dell’interfaccia, da documentare. Il metodo registra() dovrebbe anche rifiutare NaN e infinito: lo farà il progetto autonomo della sezione 16.17.

16.7 — Incapsulamento e protezione dello stato

Incapsulare significa offrire un’interfaccia stabile per utilizzare l’oggetto, limitando la dipendenza del resto del programma dai dettagli interni. Un attributo che inizia con _ comunica per convenzione che è destinato all’uso interno. Due underscore iniziali, come __codice, attivano il name mangling: il nome viene trasformato per ridurre collisioni accidentali soprattutto nell’ereditarietà. Non costituisce un confine di sicurezza e non rende il dato assolutamente inaccessibile.

class Contatore:
    def __init__(self):
        self._valore = 0

    def incrementa(self):
        self._valore += 1

    def leggi(self):
        return self._valore

c = Contatore()
c.incrementa()
print(c.leggi())  # 1

L’interfaccia pubblica è fatta di incrementa() e leggi(). L’invariante può essere, per esempio, che il contatore non diventi negativo. Esporre direttamente una lista interna consente a chi chiama di modificarla aggirando la validazione: si può restituire una copia o una tupla quando serve una vista di sola lettura.

16.8 — Proprietà, getter, setter e @property

Una proprietà permette di usare la sintassi oggetto.temperatura pur eseguendo logica di validazione. @property definisce il getter e @temperatura.setter il setter. Il valore interno deve avere un nome differente dalla proprietà stessa, per esempio _temperatura: assegnare self.temperatura = valore all’interno del suo setter provocherebbe una ricorsione involontaria.

from math import isfinite

class Termometro:
    def __init__(self, codice, temperatura):
        self._codice = codice
        self.temperatura = temperatura

    @property
    def codice(self):
        return self._codice  # senza setter: sola lettura per convenzione API

    @property
    def temperatura(self):
        return self._temperatura

    @temperatura.setter
    def temperatura(self, valore):
        if isinstance(valore, bool):
            raise ValueError("Temperatura non valida")
        t = float(valore)
        if not isfinite(t) or t < -273.15:
            raise ValueError("Temperatura fisicamente non valida")
        self._temperatura = t

    @property
    def kelvin(self):
        return self._temperatura + 273.15

s = Termometro("T1", 20)
s.temperatura = 25
print(f"{s.temperatura:.2f} °C; {s.kelvin:.2f} K")
# 25.00 °C; 298.15 K

Una proprietà calcolata come kelvin non necessita di duplicare lo stato in memoria. Il controllo sulla temperatura minima è fisico; l’intervallo massimo dipende dal sensore reale. La proprietà senza setter evita l’assegnazione ordinaria dall’esterno, ma Python non fornisce una barriera di privacy assoluta.

16.9 — Rappresentazione degli oggetti

__str__() restituisce una stringa destinata alla lettura umana e viene utilizzato da str() e normalmente da print(). __repr__() punta a una rappresentazione utile allo sviluppo e al debugging; quando pratico può avere forma simile a un’espressione ricostruttiva, ma non è un obbligo assoluto. In assenza di __str__, Python usa come ripiego __repr__.

class Misura:
    def __init__(self, valore, unita):
        self.valore, self.unita = valore, unita

    def __str__(self):
        return f"{self.valore:.2f} {self.unita}"

    def __repr__(self):
        return f"Misura({self.valore!r}, {self.unita!r})"

m = Misura(3.5, "A")
print(str(m))   # 3.50 A
print(repr(m))  # Misura(3.5, 'A')

I metodi con doppio underscore su entrambi i lati sono metodi speciali: vengono riconosciuti dal modello a oggetti di Python. Non bisogna inventare nomi di questo tipo per qualsiasi metodo ordinario.

16.10 — Ereditarietà tra classi

L’ereditarietà rappresenta una relazione concettuale «è un». Un SensoreTemperatura è un tipo particolare di Sensore: possiede le caratteristiche generali del sensore e le specializza. La sintassi class Derivata(Base): definisce una sottoclasse. Un’istanza derivata può utilizzare i metodi ereditati dalla base.

class Sensore:
    def __init__(self, codice):
        self.codice = codice

    def identifica(self):
        return f"Sensore {self.codice}"

class SensoreTemperatura(Sensore):
    unita = "°C"

s = SensoreTemperatura("T1")
print(s.identifica())  # Sensore T1
print(s.unita)        # °C

L’ereditarietà non rappresenta la relazione «contiene»: un laboratorio ha un sensore, non è un sensore. Non creare gerarchie solamente per condividere poche righe di codice: a volte la composizione è più chiara.

16.11 — Ridefinizione dei metodi e super()

Con il method overriding una classe derivata ridefinisce un metodo ereditato conservandone, di regola, l’interfaccia attesa. super() consente di richiamare implementazioni secondo la ricerca dei metodi della gerarchia; nei casi semplici serve per riusare l’inizializzazione della base e ampliare un comportamento, evitando di copiarne il codice.

class Strumento:
    def __init__(self, codice):
        self.codice = codice

    def descrivi(self):
        return f"Strumento {self.codice}"

class Termometro(Strumento):
    def __init__(self, codice, temperatura):
        super().__init__(codice)
        self.temperatura = temperatura

    def descrivi(self):
        return f"{super().descrivi()}: {self.temperatura:.2f} °C"

s = Termometro("T1", 22)
print(s.descrivi())  # Strumento T1: 22.00 °C

La sottoclasse chiama prima l’inizializzazione della base, poi assegna il proprio stato. L’overriding è diverso dall’overloading: Python non seleziona ordinariamente diversi metodi dallo stesso nome in base al numero o tipo degli argomenti come avviene in altri linguaggi.

16.12 — Polimorfismo

Polimorfismo significa poter utilizzare oggetti differenti attraverso un’interfaccia comune, ottenendo comportamenti specifici. Se più classi offrono il metodo leggi(), una funzione può chiamarlo senza conoscere tutti i dettagli di ciascun sensore. Ciò può avvenire tramite una gerarchia di ereditarietà, oppure attraverso il duck typing: in Python è spesso sufficiente che un oggetto supporti le operazioni richieste, anche senza una classe base comune.

class SensoreTemperatura:
    def leggi(self):
        return "21.50 °C"

class SensoreUmidita:
    def leggi(self):
        return "48.00 %"

class SensorePressione:
    def leggi(self):
        return "1013.00 hPa"

def mostra_letture(sensori):
    for sensore in sensori:
        print(sensore.leggi())

mostra_letture([SensoreTemperatura(), SensoreUmidita(), SensorePressione()])
# 21.50 °C
# 48.00 %
# 1013.00 hPa

La funzione non contiene una sequenza di if per riconoscere il tipo di ciascun sensore: delega a ciascun oggetto il proprio comportamento. L’interfaccia comune, tuttavia, deve avere un contratto chiaro: leggi() potrebbe restituire un numero con unità separata anziché una stringa, se occorre analisi quantitativa.

16.13 — Composizione e collaborazione tra oggetti

Con la composizione un oggetto mantiene riferimenti ad altri oggetti e ne coordina le operazioni. Per esempio, Laboratorio ha più sensori. Non eredita da Sensore, ma conserva una collezione e invoca metodi per ottenere le letture. In Python le relazioni di possesso e durata degli oggetti non sono automaticamente rigide: il termine composizione qui indica soprattutto l’architettura «ha un».

class Sensore:
    def __init__(self, codice, valore):
        self.codice, self.valore = codice, valore

    def leggi(self):
        return self.valore

class Laboratorio:
    def __init__(self):
        self.sensori = []

    def aggiungi(self, sensore):
        self.sensori.append(sensore)

    def letture(self):
        return [(s.codice, s.leggi()) for s in self.sensori]

lab = Laboratorio()
lab.aggiungi(Sensore("T1", 20))
lab.aggiungi(Sensore("T2", 22))
print(lab.letture())  # [('T1', 20), ('T2', 22)]

Si può calcolare una media solo quando i valori sono confrontabili e hanno la stessa unità fisica. Sommare indistintamente temperatura, umidità e pressione non ha significato scientifico. Per il progetto finale, ogni sensore avrà statistiche proprie.

16.14 — Classmethod, staticmethod e dataclass

Un metodo d’istanza riceve self. Un metodo decorato con @classmethod riceve invece la classe come primo argomento, convenzionalmente cls: può essere utile per costruire istanze da un formato alternativo. Un @staticmethod non riceve automaticamente né l’istanza né la classe e raccoglie una funzione logicamente collegata alla classe. Sono strumenti da usare quando chiariscono il progetto, non per trasformare ogni funzione in un metodo.

class Temperatura:
    def __init__(self, celsius):
        self.celsius = float(celsius)

    @classmethod
    def da_kelvin(cls, kelvin):
        return cls(float(kelvin) - 273.15)

    @staticmethod
    def valida_kelvin(kelvin):
        return float(kelvin) >= 0

print(f"{Temperatura.da_kelvin(300).celsius:.2f}")  # 26.85
print(Temperatura.valida_kelvin(300))               # True

Il decoratore @dataclass della libreria standard genera automaticamente metodi utili come __init__ e __repr__ per classi prevalentemente destinate a contenere dati. Le annotazioni di tipo non garantiscono da sole controlli a runtime; si può convalidare in __post_init__.

from dataclasses import dataclass

@dataclass
class Campione:
    codice: str
    valore: float

    def __post_init__(self):
        self.valore = float(self.valore)
        if not self.codice.strip():
            raise ValueError("Codice richiesto")

print(Campione("C1", 4.5))  # Campione(codice='C1', valore=4.5)

16.15 — Errori, debugging e test nella OOP

AttributeError può indicare che si sta leggendo un attributo inesistente o tentando di assegnare una proprietà priva di setter. TypeError segnala frequentemente argomenti mancanti o tipi non compatibili; ValueError è appropriato quando il tipo è accettabile ma il valore viola una regola. Per fare debugging si può stampare temporaneamente repr(oggetto) e controllare separatamente inizializzazione, modifica e lettura dello stato. È importante verificare che due istanze non condividano accidentalmente la stessa lista.

import unittest

class Contatore:
    def __init__(self):
        self.valore = 0

    def incrementa(self):
        self.valore += 1

class TestContatore(unittest.TestCase):
    def test_istanze_indipendenti(self):
        a, b = Contatore(), Contatore()
        a.incrementa()
        self.assertEqual(a.valore, 1)
        self.assertEqual(b.valore, 0)

if __name__ == "__main__":
    unittest.main()

I test con unittest sono riproducibili, documentano la specifica e diventano particolarmente utili quando cambia l’implementazione. Un programma che sembra funzionare con un solo valore non è necessariamente corretto: si devono provare casi limite, input non validi, collezioni vuote e più istanze.

16.16 — Tre esperimenti STEM completi

Esperimento A — Sensore di temperatura

Problema: simulare la lettura di una temperatura scientificamente possibile e convertirla in kelvin. Dati iniziali: identificativo T1, 20 °C, aggiornamento a 25 °C. Modello: un oggetto SensoreTemperatura possiede identificativo, temperatura in °C e unità; proprietà e setter proteggono lo stato. Algoritmo: creare il sensore, validare la temperatura, aggiornare e stampare lettura e conversione.

from math import isfinite

class SensoreTemperatura:
    unita = '°C'

    def __init__(self, codice, temperatura):
        if not codice:
            raise ValueError('Codice obbligatorio')
        self._codice = codice
        self.temperatura = temperatura

    @property
    def codice(self):
        return self._codice

    @property
    def temperatura(self):
        return self._temperatura

    @temperatura.setter
    def temperatura(self, valore):
        if isinstance(valore, bool):
            raise ValueError('Misura non valida')
        t = float(valore)
        if not isfinite(t) or t < -273.15:
            raise ValueError('Temperatura non valida')
        self._temperatura = t

    def leggi(self):
        return self.temperatura

    def __str__(self):
        return f'{self.codice}: {self.leggi():.2f} {self.unita}'

s = SensoreTemperatura('T1', 20)
s.temperatura = 25
print(s)
print(f'Kelvin: {s.leggi() + 273.15:.2f} K')

Output previsto: T1: 25.00 °C e Kelvin: 298.15 K. Interpretazione: lo stato dell’oggetto cambia solo dopo la validazione. Casi limite: -273,15 °C ammessi; -273,16 °C, infinito, NaN e booleani rifiutati. Il programma non misura una temperatura reale: simula l’acquisizione.

Esperimento B — Gerarchia di strumenti scientifici

Problema: usare strumenti differenti tramite una stessa interfaccia leggi(). Dati iniziali: temperatura 21,5 °C, umidità 48%. Modello: Strumento è la classe base; Termometro e Igrometro ridefiniscono il metodo, richiamando super() per inizializzare il codice. Algoritmo: creare due istanze e percorrere la lista invocando sempre leggi().

class Strumento:
    def __init__(self, codice):
        if not codice:
            raise ValueError('Codice obbligatorio')
        self.codice = codice

    def leggi(self):
        raise NotImplementedError('Specializzare nelle sottoclassi')

class Termometro(Strumento):
    def __init__(self, codice, valore):
        super().__init__(codice)
        self.valore = float(valore)

    def leggi(self):
        return f'{self.codice}: {self.valore:.2f} °C'

class Igrometro(Strumento):
    def __init__(self, codice, valore):
        super().__init__(codice)
        self.valore = float(valore)

    def leggi(self):
        return f'{self.codice}: {self.valore:.2f} %'

for strumento in [Termometro('T1', 21.5), Igrometro('U1', 48)]:
    print(strumento.leggi())

Output previsto: T1: 21.50 °C e U1: 48.00 %. Interpretazione: stesso metodo, implementazioni specializzate. Casi limite: codici vuoti rifiutati; l’esempio introduce il polimorfismo ma demanda la validazione dei limiti fisici alla versione completa del progetto della sezione 16.17.

Esperimento C — Laboratorio scientifico a oggetti

Problema: gestire più termometri indipendenti e calcolare statistiche sensate. Dati iniziali: T1 registra 20, 21, 22 °C; T2 non ha misure. Modello: Laboratorio contiene oggetti Sensore, che conservano storici distinti. Algoritmo: aggiungere i sensori, registrare le misure, calcolare media, minimo e massimo di ogni sensore, gestire il caso vuoto.

from statistics import mean

class Sensore:
    def __init__(self, codice):
        self.codice = codice
        self.misure = []

    def registra(self, valore):
        self.misure.append(float(valore))

    def statistiche(self):
        if not self.misure:
            return None
        return (mean(self.misure), min(self.misure), max(self.misure))

class Laboratorio:
    def __init__(self, nome):
        self.nome = nome
        self.sensori = []

    def aggiungi(self, sensore):
        self.sensori.append(sensore)

    def report(self):
        print(f'Report: {self.nome}')
        for sensore in self.sensori:
            dati = sensore.statistiche()
            if dati is None:
                print(f'{sensore.codice}: nessuna misura')
            else:
                media, minimo, massimo = dati
                print(f'{sensore.codice}: media={media:.2f}; '
                      f'min={minimo:.2f}; max={massimo:.2f} °C')

lab = Laboratorio('Scienze')
t1, t2 = Sensore('T1'), Sensore('T2')
lab.aggiungi(t1)
lab.aggiungi(t2)
for misura in (20, 21, 22):
    t1.registra(misura)
lab.report()

Output previsto: Report: Scienze, T1: media=21.00; min=20.00; max=22.00 °C, T2: nessuna misura. Interpretazione: la composizione permette al laboratorio di coordinare oggetti senza ereditare la loro natura. Casi limite: liste vuote gestite; nella versione didattica essenziale si assumono ingressi numerici validi, mentre il progetto scaricabile implementa la validazione rigorosa. Non combinare unità eterogenee in un’unica statistica.

16.17 — Progetto Python STEM scaricabile

Il progetto MEGI — Laboratorio scientifico orientato agli oggetti trasforma i concetti in un’applicazione autonoma da terminale. Comprende la classe base Strumento, tre sottoclassi (SensoreTemperatura, SensoreUmidita, SensorePressione), una classe Laboratorio che le raccoglie, proprietà di sola lettura, gestione delle eccezioni, controlli sui limiti fisici e un menu interattivo. I dati sono sintetici e non provengono da sensori reali. Non viene scritto né cancellato alcun file.

Il programma rifiuta i valori non numerici o non finiti, le temperature inferiori a -273,15 °C, l’umidità relativa esterna a 0–100% e le pressioni assolute negative. Le statistiche sono calcolate separatamente per sensore e non mescolano unità differenti. Ogni storico viene esposto come tupla di sola lettura per evitare modifiche accidentali tramite l’interfaccia pubblica. I report mostrano media, minimo, massimo e conteggio con due decimali quando opportuno.

Avvio: estrarre lo ZIP, aprire un terminale nella cartella estratta ed eseguire python MEGI_Laboratorio_OOP.py. Nel menu selezionare 5 per il report dei dati campione, 4 per registrare una nuova misura, 1–3 per aggiungere strumenti e 0 per terminare. Per i test automatici eseguire python -m unittest -v test_megi.py. Il README allegato descrive le operazioni. Il file ZIP è scaricabile come allegato a questa consegna; il suo indirizzo pubblico WordPress verrà inserito solo dopo il caricamento reale, senza link inventati.

Raccordo didattico: nell’unità precedente abbiamo imparato a salvare e interrogare record con SQLite; ora gli oggetti rappresentano entità e regole del programma. La persistenza su database non è una caratteristica automatica degli oggetti e tornerà nel progetto integrato B1.10. Nella prossima unità B1.09 costruiremo interfacce grafiche con Tkinter, mantenendo separata la logica del modello.

16.18 — Allenati con MEGI: 20 esercizi progressivi

Gli esercizi sono distribuiti in cinque livelli. Prima di aprire la soluzione, scrivi una risposta o esegui il programma in un ambiente Python. Le soluzioni sono indipendenti e possono essere esaminate singolarmente.

Esercizio 01 · Livello A — Classe e istanza

Obiettivo: Distinguere progetto e oggetto

Spiega quale elemento è la classe e quale è l’istanza in x = Misura(5).

Mostra soluzione commentata

La classe è Misura; x è un riferimento all’istanza creata dalla chiamata Misura(5).

Risultato atteso: Identificazione corretta dei due elementi.

Esercizio 02 · Livello A — Stato e comportamento

Obiettivo: Riconoscere attributi e metodi

In un termometro con temperatura e leggi(), quale elemento rappresenta lo stato?

Mostra soluzione commentata

temperatura è un attributo che descrive lo stato; leggi() è un metodo che definisce un comportamento.

Risultato atteso: Distinzione tra dati e operazioni.

Esercizio 03 · Livello A — Self

Obiettivo: Comprendere il riferimento all’istanza

Qual è la funzione di self in un metodo di istanza?

Mostra soluzione commentata

self è il riferimento all’istanza sulla quale il metodo viene chiamato. Python lo fornisce automaticamente con la sintassi oggetto.metodo().

Risultato atteso: Spiegazione del riferimento all’oggetto.

Esercizio 04 · Livello A — OOP o procedurale?

Obiettivo: Scegliere un’organizzazione appropriata

Per convertire una singola temperatura in kelvin serve necessariamente una classe?

Mostra soluzione commentata

No. Una funzione def kelvin(celsius): return celsius + 273.15 è sufficiente. Le classi servono quando si devono modellare stato e comportamenti coordinati.

Risultato atteso: Scelta motivata senza dogmatismi.

Esercizio 05 · Livello B — Due istanze

Obiettivo: Prevedere l’output

Che cosa stampa il seguente codice?

class C:
    def __init__(self, x):
        self.x = x
a, b = C(2), C(7)
print(a.x, b.x)
Mostra soluzione commentata

Stampa 2 7, perché ciascuna istanza possiede il proprio attributo x.

Risultato atteso: 2 7

Esercizio 06 · Livello B — Alias di oggetto

Obiettivo: Tracciare riferimenti

Prevedi l’output.

class C:
    def __init__(self):
        self.n = 1
a = C()
b = a
b.n = 9
print(a.n)
Mostra soluzione commentata

Stampa 9: a e b riferiscono lo stesso oggetto.

Risultato atteso: 9

Esercizio 07 · Livello B — Attributo di classe

Obiettivo: Distinguere stato condiviso

Prevedi l’output.

class S:
    unita = "V"
a, b = S(), S()
a.unita = "mV"
print(b.unita)
Mostra soluzione commentata

Stampa V: l’assegnazione a.unita = ... crea un attributo sull’istanza a, mentre b continua a leggere quello di classe.

Risultato atteso: V

Esercizio 08 · Livello B — Metodo e output

Obiettivo: Tracciare i parametri

Prevedi l’output.

class D:
    def __init__(self, n):
        self.n = n
    def doppio(self):
        return self.n * 2
print(D(6).doppio())
Mostra soluzione commentata

Il metodo usa self.n e restituisce 12.

Risultato atteso: 12

Esercizio 09 · Livello C — Self dimenticato

Obiettivo: Riparare una firma di metodo

Correggi il codice.

class S:
    def leggi():
        return 5
print(S().leggi())
Mostra soluzione commentata
class S:
    def leggi(self):
        return 5
print(S().leggi())  # 5

Il parametro self mancava nella firma.

Risultato atteso: 5

Esercizio 10 · Livello C — Attributo locale

Obiettivo: Correggere la costruzione dello stato

Il codice fallisce con AttributeError. Correggilo.

class S:
    def __init__(self, x):
        valore = x
    def leggi(self):
        return self.valore
print(S(3).leggi())
Mostra soluzione commentata
class S:
    def __init__(self, x):
        self.valore = x
    def leggi(self):
        return self.valore
print(S(3).leggi())  # 3

valore senza self era una variabile locale.

Risultato atteso: 3

Esercizio 11 · Livello C — Liste condivise

Obiettivo: Riconoscere lo stato mutabile condiviso

Perché due istanze vedono entrambe una misura appendata a misure = [] nel corpo della classe?

Mostra soluzione commentata

La lista è un attributo di classe condiviso. La soluzione è inizializzare self.misure = [] in __init__() per ottenere una lista per istanza.

Risultato atteso: Liste indipendenti.

Esercizio 12 · Livello C — Overriding

Obiettivo: Correggere la specializzazione

Analizza il metodo derivato: è presente un errore? Motiva la risposta e indica l’output atteso di leggi().

class Base:
    def leggi(self): return 4
class Figlia(Base):
    def leggi(self): return super().leggi() * 2
print(Figlia().leggi())
Mostra soluzione commentata

Il codice è già corretto: super().leggi() restituisce 4, quindi Figlia.leggi() restituisce 8. L’esercizio insegna a distinguere un errore reale da un falso allarme.

Risultato atteso: 8

Esercizio 13 · Livello D — Classe Rettangolo

Obiettivo: Implementare metodi

Scrivi una classe Rettangolo con base, altezza e metodo area(); prova 3 × 4.

Mostra soluzione commentata
class Rettangolo:
    def __init__(self, base, altezza):
        self.base, self.altezza = base, altezza
    def area(self):
        return self.base * self.altezza
print(Rettangolo(3, 4).area())  # 12

Risultato atteso: 12

Esercizio 14 · Livello D — Proprietà positiva

Obiettivo: Validare lo stato

Scrivi una classe Massa con proprietà kg che rifiuti valori negativi.

Mostra soluzione commentata
class Massa:
    def __init__(self, kg):
        self.kg = kg
    @property
    def kg(self):
        return self._kg
    @kg.setter
    def kg(self, valore):
        x = float(valore)
        if x < 0:
            raise ValueError("Massa negativa")
        self._kg = x
print(Massa(2).kg)  # 2.0

Risultato atteso: 2.0

Esercizio 15 · Livello D — Ereditarietà

Obiettivo: Specializzare una classe

Definisci Veicolo con metodo descrivi(), poi Bicicletta che lo ridefinisca.

Mostra soluzione commentata
class Veicolo:
    def descrivi(self):
        return "veicolo"
class Bicicletta(Veicolo):
    def descrivi(self):
        return "bicicletta"
print(Bicicletta().descrivi())  # bicicletta

Risultato atteso: bicicletta

Esercizio 16 · Livello D — Polimorfismo

Obiettivo: Usare un’interfaccia comune

Definisci due classi A e B con metodo leggi() diverso e richiamale in un ciclo.

Mostra soluzione commentata
class A:
    def leggi(self): return 1
class B:
    def leggi(self): return 2
for oggetto in (A(), B()):
    print(oggetto.leggi())

Il ciclo stampa 1 e 2 su due righe.

Risultato atteso: 1 poi 2

Esercizio 17 · Livello E — Sensore e validazione

Obiettivo: Modellare un sensore

Crea un sensore con codice e lettura, rifiutando una temperatura minore di -273,15 °C.

Mostra soluzione commentata
class Sensore:
    def __init__(self, codice, temperatura):
        self.codice = codice
        t = float(temperatura)
        if t < -273.15:
            raise ValueError("Temperatura impossibile")
        self.temperatura = t
print(Sensore("T", 20).temperatura)  # 20.0

Risultato atteso: 20.0

Esercizio 18 · Livello E — Strumenti diversi

Obiettivo: Applicare il polimorfismo

Costruisci due strumenti con leggi() e mostra i risultati senza controllare esplicitamente il loro tipo.

Mostra soluzione commentata
class T:
    def leggi(self): return "20 °C"
class U:
    def leggi(self): return "50 %"
def mostra(sensori):
    for s in sensori: print(s.leggi())
mostra([T(), U()])

Stampa 20 °C e 50 %.

Risultato atteso: 20 °C e 50 %

Esercizio 19 · Livello E — Laboratorio composto

Obiettivo: Utilizzare la composizione

Crea un oggetto Laboratorio che contenga due sensori e ne restituisca le letture.

Mostra soluzione commentata
class Sensore:
    def __init__(self, misura):
        self.misura = misura
    def leggi(self): return self.misura
class Laboratorio:
    def __init__(self, sensori):
        self.sensori = sensori
    def acquisisci(self):
        return [s.leggi() for s in self.sensori]
lab = Laboratorio([Sensore(4), Sensore(6)])
print(lab.acquisisci())  # [4, 6]

Risultato atteso: [4, 6]

Esercizio 20 · Livello E — Statistiche STEM

Obiettivo: Calcolare una media e gestire il vuoto

Scrivi un metodo che restituisca la media delle misure di un singolo sensore, oppure None se non ci sono misure.

Mostra soluzione commentata
from statistics import mean
class Sensore:
    def __init__(self):
        self.misure = []
    def media(self):
        return mean(self.misure) if self.misure else None
s = Sensore()
print(s.media())  # None
s.misure.extend([20, 22])
print(s.media())  # 21

Risultato atteso: None e 21

Approfondimenti MEGISTONE: B1.07 · Database Python. Il progetto Python B1.08 è consegnato separatamente come ZIP, da caricare su WordPress prima di aggiungere un pulsante di download.

Indice del capitolo

Seleziona un argomento per tornare direttamente
alla sezione corrispondente.

  1. 16.1 — Dalla programmazione procedurale agli oggetti
  2. 16.2 — Che cos’è una classe
  3. 16.3 — Oggetti e istanze
  4. 16.4 — Il metodo __init__() e l’inizializzazione
  5. 16.5 — Attributi di istanza e attributi di classe
  6. 16.6 — Metodi di istanza e comportamento degli oggetti
  7. 16.7 — Incapsulamento e protezione dello stato
  8. 16.8 — Proprietà, getter, setter e @property
  9. 16.9 — Rappresentazione degli oggetti
  10. 16.10 — Ereditarietà tra classi
  11. 16.11 — Ridefinizione dei metodi e super()
  12. 16.12 — Polimorfismo
  13. 16.13 — Composizione e collaborazione tra oggetti
  14. 16.14 — Classmethod, staticmethod e dataclass
  15. 16.15 — Errori, debugging e test nella OOP
  16. 16.16 — Tre esperimenti STEM completi
  17. 16.17 — Progetto Python STEM scaricabile
  18. 16.18 — Allenati con MEGI: 20 esercizi progressivi

Articoli simili