Classi e oggetti Python: il tutorial del 2026
La maggior parte dei tutorial OOP di Python insegnano la sintassi e saltano il modello mentale. Questo fa il contrario: te ne andrai con un'immagine chiara di cosa è una classe in fase di runtime, quando cercare @dataclass invece di scrivere __init__ a mano e come funziona realmente self (non è magia).
Tratteremo: la classe minima utilizzabile di quattro righe, perché "self" è un parametro, gli attributi di classe e istanza (il bug per principianti n. 1), i sei metodi dunder che vedrai ovunque, "@dataclass" come impostazione predefinita moderna e una regola rigida su quando lasciare le classi da sole e utilizzare una funzione semplice.
Il modello mentale: una classe è una fabbrica
Una classe in Python è una fabbrica che produce oggetti. Ogni volta che chiami Rect(3, 4), Python crea un nuovo oggetto con la propria memoria e te lo restituisce.
Questa è l'intera meccanica. La classe è il progetto; ogni chiamata Rect(...) è un timbro del progetto nella nuova RAM.
self è solo un parametro
La confusione numero 1 per chi proviene da JS o Ruby: self in Python è esplicita. Il primo parametro di ogni metodo è un riferimento all'istanza chiamata.
Quindi c.bump() è lo zucchero sintattico per Counter.bump(c). Python passa l'istanza come primo argomento. Potresti chiamarlo "me", "questo" o "foo": "self" è una convenzione, non una parola chiave. Attieniti a self (PEP 8) in modo che altri sviluppatori Python possano leggere il tuo codice.
La trappola degli attributi classe vs istanza
Il bug OOP Python più comune in una codebase per principianti:
items = [] nell'ambito della classe crea UN elenco condiviso da ogni istanza. a.add("milk") lo modifica, quindi b.items vede lo stesso elenco.
Regola: inizializza lo stato mutabile in `__init__`, non nell'ambito della classe.
Questo bug è stato inviato in produzione più volte di quanto qualsiasi sviluppatore Python ammetterà. Fai attenzione a elenchi, dettami e insiemi nell'ambito della classe.
I sei metodi che vedrai ovunque
I metodi Dunder (__name__) sono gli hook di sovraccarico degli operatori di Python. Questi sei coprono il 95% di ciò che incontrerai:
1. __init__(self, ...) — costruttore
Viene eseguito quando viene creato l'oggetto. Imposta qui gli attributi dell'istanza. Non restituisce nulla (Python impone None).
2. __repr__(self) — stringa rivolta allo sviluppatore
Chiamato da print(x) se manca __str__ e sempre da REPL. Punta a qualcosa che potresti incollare nuovamente in Python per ricreare l'oggetto:
3. __eq__(sé, altro) — uguaglianza
Senza di esso, "Rect(3, 4) == Rect(3, 4)" restituisce "False" (il valore predefinito è identità). Confronta campo per campo:
4. __hash__(self) — capacità di hash
Se sovrascrivi __eq__, DEVI sovrascrivere anche __hash__ o Python imposta __hash__ = None (l'oggetto diventa unhashable). Il più semplice: return hash((self.width, self.height)).
5. __len__(self) — per len(obj)
Fa funzionare len(cart) == 5.
6. __iter__(self) — per for x in obj:
Restituisce un iteratore. yield all'interno rende la classe iterabile:
@dataclass — l'impostazione predefinita moderna
Se la tua classe è principalmente un detentore di dati (tre campi, un __init__, un __repr__, un __eq__), smetti di scrivere quel boilerplate. @dataclass genera tutto dalle annotazioni del tipo:
Sono __init__, __repr__ e __eq__ tutti generati. Aggiungi @dataclass(frozen=True) per rendere l'oggetto immutabile E ottenere __hash__ gratuito.
Regola: raggiungere prima `@dataclass`. Scrivi una classe creata manualmente solo quando hai bisogno di metodi che non siano funzioni di accesso agli attributi.
__slots__ — ottimizzazione della memoria (avanzata)
Per impostazione predefinita ogni istanza contiene un __dict__ quindi puoi aggiungere attributi arbitrari. __slots__ sostituisce tale impostazione con una struttura fissa di livello C: ingombro RAM ridotto e accesso agli attributi più rapido:
Usa __slots__ quando: (a) stai creando milioni di istanze e problemi di RAM, o (b) vuoi rilevare l'assegnazione di attributi errori di battitura in fase di runtime. Altrimenti saltalo: disabilita pickle per impostazione predefinita e interrompe l'ereditarietà multipla in modi sottili.
Quando abbandonare le lezioni da solo
Regola dura: se la tua classe ha UN metodo più `__init__`, probabilmente dovrebbe essere una funzione.
Le classi guadagnano il loro peso quando mantengono state su più chiamate di metodo o quando implementano un protocollo ben definito (__iter__, __enter__, __eq__, ecc.). La logica one-shot è una funzione.
Eredità: usala con parsimonia
L’ereditarietà è reale ma abusata. Nel 2026 Python, preferisce composizione: mantieni un altro oggetto come attributo invece di ereditare da esso:
Eredita solo quando hai una vera relazione "è-a" E vuoi ignorare il comportamento. Un NamedRect che eredita da Rect per aggiungere un campo name va bene. Costruire una gerarchia di ereditarietà a cinque livelli per una classe di logica aziendale è un codice che risolverai in 6 mesi.
Le classi sono una delle funzionalità più potenti di Python e una delle più facili da utilizzare in modo eccessivo. Il modello mentale che aiuta: una classe è una fabbrica di oggetti, "self" è un parametro semplice, lo stato modificabile va in "__init__", cerca prima "@dataclass" e torna a una funzione ogni volta che la classe ha meno di due metodi che trasportano lo stato.
Passaggio successivo: 30 lezioni pratiche OOP che coprono classi, @dataclass, ereditarietà vs composizione e metodi dunder, con Python reale in esecuzione nel tuo browser e un mentore AI in ogni passaggio.