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

Una classe raggruppa i dati e quello che ci fai

Una classe ti permette di definire un tipo di cosa (un utente, un conto bancario, una configurazione, una richiesta) e tutto quello che quella cosa deve saper fare. La cosa è un'istanza della classe. Le azioni si chiamano metodi.

Ecco la classe più semplice possibile:

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def greet(self):
        print(f"Hi, I'm {self.name}. Reach me at {self.email}.")

user = User("Rosa", "rosa@example.com")
user.greet()

print(user.name)
print(user.email)

Vediamola pezzo per pezzo:

• class User: inizia la definizione di una classe. Per convenzione i nomi delle classi usano il PascalCase.
• __init__ è l'inizializzatore. Viene eseguito automaticamente quando crei una nuova istanza. Imposta gli attributi dell'istanza con self.whatever = ....
• greet è un metodo. self è il modo in cui un metodo si riferisce all'istanza su cui è stato chiamato.
• User("Rosa", "rosa@example.com") crea un'istanza. Python chiama __init__ con self impostato sulla nuova istanza e gli altri argomenti passati così come sono.
• user.greet() chiama il metodo. Python passa automaticamente user come self.

self è solo il primo argomento

self non è una parola chiave. È il nome dato al primo parametro dei metodi di istanza, cioè l'istanza su cui il metodo sta girando. Potresti chiamarlo in qualsiasi modo; tutti usano self perché lo fanno tutti.

Ogni metodo di istanza riceve self come primo parametro. È così che un metodo sa da quale istanza leggere o quale modificare.

Aggiungere comportamento

I metodi possono leggere e modificare lo stato:

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

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

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

a = BankAccount("Rosa", 100)
a.deposit(50)
a.withdraw(30)
print(a)

__repr__ è un altro metodo speciale: un aggancio che dice "come mostro questo oggetto quando viene stampato?". Definirne uno fatto bene ripaga ampiamente durante il debug.

Attributi di classe e attributi di istanza

Gli attributi definiti nel corpo della classe (fuori da __init__) sono condivisi tra tutte le istanze. Gli attributi assegnati a self sono propri di ogni istanza:

class Dog:
    species = "Canis familiaris"   # attributo di classe, condiviso

    def __init__(self, name):
        self.name = name           # attributo di istanza, per ogni cane

a = Dog("Rex")
b = Dog("Luna")

print(a.species, a.name)
print(b.species, b.name)

Dog.species = "Canis lupus familiaris"  # cambia per ogni istanza
print(a.species, b.species)

Usa gli attributi di classe per valori davvero condivisi: costanti, contatori, configurazione. Metti i dati specifici dell'istanza in __init__.

Ereditarietà

Una classe può ereditare da un'altra, ottenendone gratis metodi e attributi e aggiungendo o ridefinendo quello che serve:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

rex = Dog("Rex")
luna = Cat("Luna")
rex.speak()
luna.speak()

super() ti dà accesso alla classe genitore. Si usa spesso dentro __init__ per inizializzare gli attributi del genitore prima di aggiungere i tuoi:

class Animal:
    def __init__(self, name):
        self.name = name

class LabeledDog(Animal):
    def __init__(self, name, tag_number):
        super().__init__(name)
        self.tag_number = tag_number

d = LabeledDog("Rex", tag_number=42)
print(d.name, d.tag_number)

L'ereditarietà è utile ma è facile abusarne. Chi inizia con Python ricorre spesso all'ereditarietà quando la composizione (tenere un oggetto come attributo) sarebbe più chiara. Parti con una struttura di classi piatta e introduci l'ereditarietà solo quando c'è una vera relazione "è un".

La pagina sull'ereditarietà in Python va oltre: estendere un metodo del genitore con super(), isinstance e issubclass, classi base astratte, ereditarietà multipla e ordine di risoluzione dei metodi.

Dataclass: una scelta migliore per i record

Quando ti serve soprattutto una classe che contenga qualche attributo con un comportamento di uguaglianza e di rappresentazione, @dataclass ti risparmia un sacco di codice ripetitivo:

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(3.0, 4.0)
q = Point(3.0, 4.0)

print(p)
print(p == q)     # True: le dataclass gestiscono l'uguaglianza automaticamente
print(p.x, p.y)

Confrontalo con lo scrivere a mano __init__, __repr__ e __eq__. Le dataclass sono la prima scelta giusta quando altrimenti scriveresti una class Thing con solo un __init__ che imposta attributi.

Property: attributi calcolati

A volte vuoi un "attributo" che in realtà viene calcolato. @property lo fa sembrare un normale accesso a un attributo:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)       # si usa come un attributo, non c.area()

Usa le property quando scriveresti obj.get_something(): sostituirlo con una property rende l'API più naturale. Non usarle per nascondere operazioni costose; chi le usa si aspetta che l'accesso a un attributo sia veloce.

Privato per convenzione

Python non ha un vero concetto di privato. Per convenzione, gli attributi con un underscore iniziale sono pensati come privati: chi legge il codice non dovrebbe toccarli dall'esterno della classe:

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

I nomi con doppio underscore (__name) attivano il name mangling, che aggiunge il nome della classe all'attributo. È uno strumento per evitare collisioni nell'ereditarietà, non una misura di sicurezza.

Quando non usare una classe

Se hai solo un insieme di dati collegati, una dataclass, un semplice dict o una named tuple vanno benissimo. Se hai solo una funzione, non serve una classe per contenerla. Ricorri alle classi quando hai sia stato sia comportamento legati insieme, soprattutto se avrai molte istanze dello stesso tipo.

Un esempio finale

Un piccolo buffer di log simile a un file:

from datetime import datetime

class Logger:
    def __init__(self, name):
        self.name = name
        self._entries = []

    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self._entries.append(f"[{timestamp}] {self.name}: {message}")

    def dump(self):
        return "\n".join(self._entries)

    def __len__(self):
        return len(self._entries)

logger = Logger("api")
logger.log("starting")
logger.log("ready")
logger.log("shutting down")

print(logger.dump())
print(len(logger))

Nota __len__, un altro metodo magico. Definirlo fa funzionare len(logger), perché len(x) in realtà è una chiamata a x.__len__(). Python ha decine di questi agganci; li imparerai man mano che ti servono.