Man mano che uno script cresce, finisci per passare lo stesso gruppo di variabili tra le funzioni e diventa difficile dire quali dati appartengono a quale logica. Classi e oggetti Python risolvono questo problema raggruppando dati e comportamenti in un’unica unità.

In questo tutorial creiamo passo dopo passo un piccolo conto bancario e aggiungiamo ogni idea OOP solo quando risolve un problema. Abbiamo eseguito ogni esempio su Python 3.13 e l’output mostrato proviene da quell’esecuzione. Se non conosci il linguaggio, leggi prima il nostro tutorial Python per principianti.

Cosa sono le classi e gli oggetti?

Una classe descrive cos’è qualcosa e cosa può fare. Un oggetto, chiamato anche istanza, è un oggetto specifico creato da quella descrizione. “Account” è una classe, mentre l’account di Asha e l’account di Ben sono due oggetti.

Hai sempre usato oggetti. In Python, stringhe, elenchi e persino funzioni sono oggetti, motivo per cui puoi scrivere "hello".upper().

La tua prima lezione

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ viene eseguito automaticamente ogni volta che crei un oggetto e imposta lo stato iniziale. Il deposito in a non ha toccato b, perché ogni oggetto ha i propri dati. Si noti che il metodo protegge anche il saldo da un valore errato. La nostra guida alla gestione delle eccezioni Python spiega raise in modo più approfondito.

Cos’è il sé?

self è semplicemente l’oggetto su cui sta lavorando un metodo. Quando scrivi a.deposit(50), Python chiama effettivamente Account.deposit(a, 50), passando l’oggetto come primo argomento. Ecco come una definizione di metodo può servire ogni oggetto.

Il nome self è una convenzione forte piuttosto che una parola chiave, ma usalo sempre. Dimenticarlo nella definizione di un metodo è l’errore più comune per i principianti e produce un messaggio confuso sul numero di argomenti.

Attributi di classe e attributi di istanza

Un attributo impostato direttamente nel corpo della classe è condiviso da tutti gli oggetti. Un set su self appartiene solo a quell’oggetto. Questo esempio mostra come si comportano le ricerche:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Quest’ultima riga sorprende le persone. L’assegnazione tramite a non ha modificato il valore condiviso. Ha creato un nuovo attributo di istanza su a che nasconde quello di classe. Python esamina prima l’oggetto, poi la classe.

Metodi speciali (dunder).

I metodi con doppi caratteri di sottolineatura consentono ai tuoi oggetti di funzionare con le funzionalità integrate di Python. Senza di essi, la stampa di un account mostra un indirizzo di memoria inutile. L’aggiunta di due dà una forma leggibile:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Eredità

L’ereditarietà consente a una nuova classe di riutilizzarne una esistente e di modificare solo ciò che differisce. Qui, Savings è un Account con un’impostazione aggiuntiva:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() chiama la versione del genitore, quindi la logica di installazione non viene ripetuta. deposit è stato ereditato così com’era e __str__ è stato sovrascritto per aggiungere un’etichetta. Utilizzare l’ereditarietà solo per una relazione reale “è un”. Se una classe ha semplicemente bisogno di qualcosa, come un’auto che necessita di un motore, assegnale quell’oggetto come attributo. Questo è noto come composizione e di solito è più flessibile delle catene di ereditarietà profonde.

Polimorfismo

Il polimorfismo significa che oggetti diversi possono rispondere alla stessa chiamata di metodo a modo loro. Non è necessario che il codice chiamante conosca il tipo esatto:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Queste due classi non condividono nemmeno un genitore. A Python interessa solo che l’oggetto abbia un metodo area, un approccio noto come ducktyping. L’aggiunta di un Triangle in un secondo momento non richiederebbe alcuna modifica al loop.

Incapsulamento e proprietà

Python non ha attributi veramente privati e si basa invece su convenzioni. Un singolo carattere di sottolineatura, come in _price, dice agli altri sviluppatori “questo è interno, per favore non toccarlo”. Per controllare i valori quando sono impostati, utilizza una property, che sembra un semplice attributo dall’esterno:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Ciò significa che puoi iniziare con un attributo semplice e aggiungere la convalida in seguito senza modificare alcun codice che utilizza la classe. Quindi non scrivere i metodi get_price() e set_price() per abitudine, come potresti fare in Java. La @ sintassi qui è un decoratore, che spiegheremo in Spiegazione dei decoratori Python.

Metodi di classe e metodi statici

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Classi dati

Quando una classe contiene principalmente dati, scrivere __init__, __repr__ e __eq__ a mano è noioso. @dataclass li genera dalle annotazioni di tipo:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Errori comuni

Utilizzando un attributo di classe mutabile

Questo è un bug classico. L’elenco è definito nella classe, quindi tutti i carrelli lo condividono:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Crealo in __init__ con self.items = [], in modo che ogni oggetto abbia il proprio elenco.

Altri errori comuni

• Dimenticare self. Scrivere self.balance, non balance, all’interno dei metodi.
• Dimenticare super().__init__(). Il bambino perde quindi gli attributi impostati dal genitore.
• Creare classi enormi. Una classe che fa tutto è difficile da testare. Dividilo per responsabilità.
• Ereditarietà profonda. Due livelli sono generalmente sufficienti e la composizione è spesso più chiara.
• Non scrivere test. Le classi con regole sono facili da testare, come mostra il nostro tutorial pytest utilizzando un piccolo carrello.

Considerazioni finali

Python orientato agli oggetti si riduce al raggruppamento dei dati con il comportamento che li protegge. Inizia con __init__, metodi e __str__, quindi aggiungi ereditarietà e proprietà quando incontri un problema che risolvono. Come passo successivo, prendi uno script che passi le stesse poche variabili ovunque e trasformale in un’unica piccola classe.

Domande frequenti

Continua a imparare