Classi e OOP in Python: __init__, self, metodi, ereditarietà e dataclass

Una classe in Python è un modello: descrive quali dati conserva un oggetto e che cosa si può fare con essi. L'oggetto (istanza) è un esemplare concreto costruito secondo quel modello. La programmazione orientata agli oggetti in Python poggia su tre elementi: le classi con i loro metodi, l'ereditarietà e i metodi speciali come __init__ e __repr__. Vediamo tutto in ordine, con un unico esempio che ricorre: la gestione delle spese.

Perché servono le classi se esistono i dizionari

I dati si possono conservare in un dizionario: {"title": "Caffè", "amount": 250}. Il problema è che il dizionario non sa quali chiavi siano corrette. Un refuso come expense.get("amout", 0) non genera alcun errore: restituisce zero, e il report inizia a mentire in silenzio.

Un oggetto di classe ha campi dichiarati in anticipo. L'accesso a un attributo inesistente produce subito AttributeError, e Python moderno suggerisce anche il nome corretto. Inoltre la classe raccoglie in un solo punto i dati e le azioni su di essi: una spesa sa calcolare da sola l'importo con l'IVA, un report calcola da sé il totale.

Come creare una classe in Python

La classe si dichiara con la parola class, e il nome secondo la PEP 8 si scrive in CamelCase. Un esempio minimo:

class Expense:
    def __init__(self, title, amount):
        self.title = title
        self.amount = amount

coffee = Expense("Caffè", 250)
taxi = Expense("Taxi", 300)
print(coffee.title, coffee.amount)   # Caffè 250

La chiamata Expense("Caffè", 250) crea una nuova istanza della classe. coffee e taxi sono due oggetti diversi dello stesso tipo, ciascuno con i propri valori dei campi. Verificare l'appartenenza si può con isinstance(coffee, Expense), che restituisce True.

Costruttore __init__: inizializzazione della classe

__init__ viene spesso chiamato costruttore, anche se in senso stretto è un inizializzatore. L'oggetto viene creato dal metodo __new__, mentre __init__ viene eseguito subito dopo e distribuisce gli argomenti ricevuti sui campi. Non deve restituire nulla (per la precisione deve restituire None).

In __init__ è comodo verificare i dati in ingresso, per evitare che nel programma compaiano oggetti evidentemente sbagliati:

class Expense:
    def __init__(self, title, amount):
        if amount < 0:
            raise ValueError("L'importo non può essere negativo")
        self.title = title
        self.amount = amount

Che cos'è self in Python

self è il riferimento all'oggetto su cui sta lavorando il metodo in quel momento. Quando scrivete coffee.with_tax(), Python chiama in realtà Expense.with_tax(coffee) e passa l'oggetto come primo argomento. Per questo nella dichiarazione del metodo self sta per primo, mentre nella chiamata non si scrive.

self non è una parola chiave ma una convenzione: tecnicamente il parametro può avere qualsiasi nome, ma nessuno lo fa. L'errore tipico dei principianti è dimenticare self nella dichiarazione del metodo. Allora la chiamata genera TypeError: Expense.with_tax() takes 0 positional arguments but 1 was given.

Metodi di classe e metodi speciali

Un metodo è una funzione dichiarata dentro la classe. Vede i campi dell'oggetto tramite self:

class Expense:
    def __init__(self, title, amount):
        self.title = title
        self.amount = amount

    def with_tax(self, rate=0.2):
        return self.amount * (1 + rate)

    def __repr__(self):
        return f"Expense({self.title!r}, {self.amount})"

coffee = Expense("Caffè", 250)
print(coffee.with_tax())   # 300.0
print(coffee)              # Expense('Caffè', 250)

Senza __repr__ la stampa mostrerebbe <__main__.Expense object at 0x7f...>: inutile per il debug. I metodi con due trattini bassi su entrambi i lati si chiamano speciali (dunder, da double underscore): Python li invoca da solo. __str__ si occupa dell'output «leggibile» per l'utente, __eq__ del confronto con ==, __len__ di len(obj).

@classmethod e @staticmethod

Un metodo normale lavora con l'istanza. Un metodo di classe, con il decoratore @classmethod, riceve come primo argomento la classe stessa (cls): spesso serve come costruttore alternativo. Un metodo statico, con @staticmethod, non riceve né l'oggetto né la classe: è una normale funzione che logicamente appartiene alla classe.

class Expense:
    def __init__(self, title, amount):
        self.title = title
        self.amount = amount

    @classmethod
    def from_csv(cls, line):
        title, amount = line.split(";")
        return cls(title, float(amount))

    @staticmethod
    def is_valid_amount(value):
        return value >= 0

e = Expense.from_csv("Pranzo;520")
print(e.amount)                    # 520.0
print(Expense.is_valid_amount(-1)) # False

Distruttore di classe: __del__

In Python esiste il metodo __del__, che viene chiamato prima che l'oggetto venga distrutto dal garbage collector. Non conviene affidarsi a esso per liberare risorse: il momento della chiamata non è garantito. Per file e connessioni usate il gestore di contesto with oppure il metodo esplicito close().

Attributi di classe e attributi di istanza

I campi assegnati con self.nome = ... appartengono al singolo oggetto. Le variabili dichiarate direttamente nel corpo della classe sono attributi di classe: sono condivisi da tutte le istanze. Di solito in questo modo si conservano le costanti di classe.

class Expense:
    CURRENCY = "EUR"          # attributo di classe, costante

    def __init__(self, title, amount):
        self.title = title    # attributi di istanza
        self.amount = amount

a = Expense("Caffè", 250)
b = Expense("Tè", 150)
print(a.CURRENCY, Expense.CURRENCY)   # EUR EUR

Una trappola pericolosa è l'attributo di classe mutabile. Se nel corpo della classe scrivete rows = [] e aggiungete elementi con self.rows.append(...), la lista diventa comune a tutti gli oggetti. I campi mutabili vanno sempre creati dentro __init__.

I campi di un oggetto si vedono con vars(obj) oppure obj.__dict__, mentre un attributo si legge per nome da una stringa con getattr(obj, "amount").

Proprietà di classe: @property

Una proprietà è un metodo che dall'esterno si legge come un campo normale, senza parentesi. È comoda per i valori calcolati: il totale del report non va memorizzato a parte e non rischia di non essere aggiornato.

class Report:
    def __init__(self):
        self.rows = []

    def add(self, expense):
        self.rows.append(expense)

    @property
    def total(self):
        return sum(e.amount for e in self.rows)

r = Report()
r.add(Expense("Caffè", 250))
r.add(Expense("Taxi", 300))
print(r.total)   # 550

Se serve controllare la scrittura, alla proprietà si aggiunge un setter con @total.setter. Senza setter l'assegnazione r.total = 0 genera AttributeError.

Una nota sull'incapsulamento. In Python non esistono campi privati in senso stretto. Un trattino basso (_cache) è una convenzione del tipo «non toccate dall'esterno», due trattini bassi (__segreto) attivano il name mangling, così che un discendente non sovrascriva il campo per errore.

Ereditarietà delle classi in Python

L'ereditarietà permette di creare una classe figlia a partire da una classe genitore: il figlio riceve tutti i campi e i metodi, e può ridefinire quelli che servono. La classe genitore si indica tra parentesi.

class MonthlyReport(Report):
    def __init__(self, month):
        super().__init__()        # richiama __init__ del genitore
        self.month = month

    def add(self, expense):       # ridefinizione del metodo
        print(f"[{self.month}] + {expense}")
        super().add(expense)      # mantiene il comportamento del genitore

m = MonthlyReport("ottobre")
m.add(Expense("Caffè", 250))   # [ottobre] + Expense('Caffè', 250)
print(m.total)                 # 250 — la proprietà è ereditata

super() restituisce un oggetto intermediario per richiamare i metodi del genitore. Dimenticare super().__init__() nel __init__ del figlio è un errore classico: il campo rows non viene creato, e il primo add genera AttributeError.

Per verificare la parentela si usa issubclass(MonthlyReport, Report). In Python 3 tutte le classi ereditano implicitamente da object, da cui arrivano __repr__, __eq__ e gli altri metodi di base. Python supporta anche l'ereditarietà multipla (class C(A, B)); l'ordine di ricerca dei metodi si vede in C.__mro__.

Classe astratta in Python

La classe astratta definisce un'interfaccia: quali metodi devono essere implementati dalle sottoclassi. Non si può creare un'istanza di una classe astratta. Serve il modulo abc:

from abc import ABC, abstractmethod

class Exporter(ABC):
    @abstractmethod
    def export(self, report): ...

class CsvExporter(Exporter):
    def export(self, report):
        return "\n".join(f"{e.title};{e.amount}" for e in report.rows)

Exporter()   # TypeError: Can't instantiate abstract class Exporter ...

Una sottoclasse che non implementa tutti i metodi astratti resta anch'essa astratta e genera lo stesso errore alla creazione dell'oggetto.

Composizione al posto delle gerarchie profonde

Dopo aver conosciuto l'ereditarietà viene voglia di costruire scale: spesa base, spesa in denaro, spesa in euro, e così via per cinque livelli. In Python lo si fa raramente. L'ereditarietà descrive il rapporto «è un», la composizione quello «contiene»: un report non è una lista di spese, la contiene nel campo rows.

Regola pratica: se serve solo usare una capacità di un altro oggetto, mettetelo in un campo invece di ereditare. Per i dati spesso basta un dataclass, mentre la logica può restare in normali funzioni.

Dataclass in Python: classe senza codice ripetitivo

Per le classi che contengono soprattutto dati, scrivere a mano __init__, __repr__ e __eq__ è noioso. Il decoratore @dataclass del modulo dataclasses li genera a partire dalle annotazioni dei campi:

from dataclasses import dataclass, field

@dataclass
class Expense:
    title: str
    amount: float
    tags: list[str] = field(default_factory=list)

    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("L'importo non può essere negativo")

e = Expense("Caffè", 250)
print(e)                           # Expense(title='Caffè', amount=250, tags=[])
print(e == Expense("Caffè", 250))  # True

La verifica dei valori che prima si scriveva in __init__ si sposta in __post_init__, che viene chiamato subito dopo l'inizializzatore generato. I valori predefiniti mutabili si indicano solo tramite field(default_factory=list): la scrittura tags: list = [] viene rifiutata dal dataclass con ValueError.

frozen e slots

Il parametro frozen=True rende l'oggetto immutabile, mentre slots=True (dalla versione 3.10) crea un __slots__ e fa risparmiare memoria. Il tentativo di modificare un campo di un oggetto congelato genera FrozenInstanceError. Per ottenere un oggetto con un nuovo valore si crea una copia:

from dataclasses import dataclass, replace

@dataclass(frozen=True, slots=True)
class Expense:
    title: str
    amount: float

e = Expense("Caffè", 250)
# e.amount = 300   -> dataclasses.FrozenInstanceError
e2 = replace(e, amount=300)
print(e, e2)   # Expense(title='Caffè', amount=250) Expense(title='Caffè', amount=300)

Dalla versione 3.13 la stessa operazione è disponibile anche con la funzione universale copy.replace(). Gli oggetti dataclass congelati si possono inserire nei set e usare come chiavi di dizionario, perché hanno un __hash__.

Novità nelle classi: Self, @override, __slots__

Per la tipizzazione delle classi ci sono due strumenti utili. typing.Self (Python 3.11, PEP 673) indica «verrà restituito un oggetto della stessa classe»: funziona anche nei metodi ereditati. Il decoratore @override (Python 3.12, PEP 698) segnala un metodo che deve ridefinire quello del genitore: se avete sbagliato il nome, mypy o pyright segnalano che nella classe base non esiste un metodo con quel nome.

from typing import Self, override

class Report:
    def __init__(self):
        self.rows = []

    def add(self, e) -> Self:
        self.rows.append(e)
        return self              # si può concatenare le chiamate

class MonthlyReport(Report):
    @override
    def add(self, e) -> Self:
        return super().add(e)

In Python 3.15 è stata eliminata una limitazione di nicchia: alle sottoclassi di tuple si possono assegnare __slots__ non vuoti, e __dict__ e __weakref__ si possono indicare in __slots__ di qualsiasi classe. Nella 3.14 una dichiarazione del genere in una sottoclasse della tupla generava TypeError: nonempty __slots__ not supported for subtype of 'tuple'.

Errori frequenti con le classi

Conclusioni

La OOP in Python parte da una cosa semplice: la classe descrive campi e metodi, __init__ riempie i campi, self indica l'oggetto corrente. Ereditarietà e super() permettono di estendere il comportamento, le classi astratte definiscono un'interfaccia, @property rende calcolabili i campi. Per le classi-dati usate @dataclass, mentre per le gerarchie profonde preferite la composizione. Classi e dataclass sono trattati in pratica nella lezione del corso di Python sull'esempio del tracker delle spese.