Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Prontuario Python10. Le classi

Le classi

class, self, attributi e metodi, repr e str, ereditarietà, super, isinstance, dataclass e il ponte con Pydantic

Una classe è lo stampo, un oggetto è una cosa fatta con quello stampo. La classe Treno dice che ogni treno ha un codice e un ritardo, e cosa sa fare; Treno("T-07") è un treno vero. Ogni voce dice a cosa serve, mostra un esempio da provare e la cosa da ricordare. Nel codice, # → dice cosa vale quella riga, o cosa stampa.

La spiegazione lunga è nei capitoli Classi e oggetti ed Ereditarietà.

class e il costruttore

class crea lo stampo. Il metodo __init__ (due trattini bassi prima e dopo) è il costruttore: parte da solo quando crei un oggetto con Treno(...) e gli dà i suoi primi valori.

Python
class Treno:
    def __init__(self, codice, linea):
        self.codice = codice
        self.linea = linea
        self.ritardo = 0


t7 = Treno("T-07", "Menta")
t7.codice  # → 'T-07'
t7.linea  # → 'Menta'
t7.ritardo  # → 0
type(t7)  # → <class '__main__.Treno'>
Treno("T-12")  # → TypeError: Treno.__init__() missing 1 required positional argument: 'linea'

Il nome della classe ha l'iniziale maiuscola. Gli argomenti di Treno("T-07", "Menta") arrivano a codice e linea; il primo parametro, self, lo riempie Python.

self

self è l'oggetto su cui stai lavorando. Quando scrivi la classe non sai ancora se sarà il T-07 o il T-12: scrivi self, e a ogni chiamata Python ci mette l'oggetto giusto.

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0

    def ritarda(self, minuti):
        self.ritardo = self.ritardo + minuti


t7 = Treno("T-07")
t12 = Treno("T-12")
t7.ritarda(5)
t7.ritardo  # → 5
t12.ritardo  # → 0

Treno.ritarda(t12, 2)
t12.ritardo  # → 2

t7.ritarda(5) è come Treno.ritarda(t7, 5): l'oggetto prima del punto diventa self. Per questo ogni treno ha il suo ritardo.

Gli attributi

Le variabili attaccate a un oggetto, come codice e ritardo. Si leggono e si cambiano con il punto.

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0


t7 = Treno("T-07")
t7.ritardo = 3
t7.ritardo  # → 3
t7.ritardo += 2
t7.ritardo  # → 5
t7.colore  # → AttributeError: 'Treno' object has no attribute 'colore'
vars(t7)  # → {'codice': 'T-07', 'ritardo': 5}

vars mostra tutti gli attributi di un oggetto in un dizionario: comodo quando non sai cosa c'è dentro. Gli attributi creali tutti nell'__init__, anche quelli che partono da zero: così ogni oggetto della classe ha gli stessi.

I metodi

Le funzioni che stanno dentro la classe. Il primo parametro è sempre self. Un metodo può cambiare l'oggetto oppure calcolare e restituire qualcosa.

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0

    def ritarda(self, minuti):
        self.ritardo += minuti

    def in_orario(self):
        return self.ritardo == 0

    def annuncio(self):
        if self.in_orario():
            return f"{self.codice} è in orario"
        return f"{self.codice} ha {self.ritardo} minuti di ritardo"


t7 = Treno("T-07")
t7.in_orario()  # → True
t7.annuncio()  # → 'T-07 è in orario'
t7.ritarda(4)
t7.annuncio()  # → 'T-07 ha 4 minuti di ritardo'

Dentro un metodo, gli attributi e gli altri metodi dello stesso oggetto si raggiungono con self.: self.ritardo, self.in_orario().

Chiamare un metodo

Oggetto, punto, nome del metodo, parentesi. Le parentesi ci vogliono sempre, anche quando sono vuote.

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 7

    def in_orario(self):
        return self.ritardo == 0


t7 = Treno("T-07")
t7.in_orario()  # → False
bool(t7.in_orario)  # → True

Nel terminale, un metodo senza parentesi si presenta così (il numero dopo at cambia ogni volta):

>>> t7.in_orario
<bound method Treno.in_orario of <__main__.Treno object at 0x1027ea210>>

Il self dimenticato

L'errore più comune con le classi. Se nella def di un metodo manca self, Python 3.12 dice così:

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice

    def saluta():
        return "Benvenuti a bordo"


t7 = Treno("T-07")
t7.saluta()  # → TypeError: Treno.saluta() takes 0 positional arguments but 1 was given

«takes 0 … but 1 was given»: tu tra le parentesi non hai messo niente, ma Python passa sempre l'oggetto come primo argomento. La cura è def saluta(self):.

Anche il self. davanti agli attributi si dimentica. Dentro un metodo, codice da solo è una variabile che non esiste:

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice

    def annuncio(self):
        return f"Treno {codice} in arrivo"


t7 = Treno("T-07")
t7.annuncio()  # → NameError: name 'codice' is not defined

E nell'__init__, senza self. il valore finisce in una variabile che sparisce appena il costruttore ha finito:

Python
class Treno:
    def __init__(self, codice):
        codice = codice


t7 = Treno("T-07")
t7.codice  # → AttributeError: 'Treno' object has no attribute 'codice'

repr e str

Un oggetto senza istruzioni si stampa così, con l'indirizzo in memoria che cambia a ogni esecuzione e non ti dice niente:

>>> t7 = Treno("T-07")
>>> t7
<__main__.Treno object at 0x1027ea210>

Con i metodi __repr__ e __str__ decidi tu cosa mostrare.

Python
class Treno:
    def __init__(self, codice, ritardo=0):
        self.codice = codice
        self.ritardo = ritardo

    def __repr__(self):
        return f"Treno('{self.codice}', {self.ritardo})"

    def __str__(self):
        return f"Treno {self.codice}, ritardo {self.ritardo} min"


t7 = Treno("T-07", 3)
t7  # → Treno('T-07', 3)
print(t7)  # → Treno T-07, ritardo 3 min
str(t7)  # → 'Treno T-07, ritardo 3 min'
f"In arrivo: {t7}"  # → 'In arrivo: Treno T-07, ritardo 3 min'
[t7, Treno("T-12")]  # → [Treno('T-07', 3), Treno('T-12', 0)]

__repr__ è per chi programma: lo vedi nel terminale, nel debugger, dentro le liste. Di solito somiglia al codice che crea l'oggetto. __str__ è per chi legge: lo usano print, str e le f-string. Se scrivi solo __repr__, Python lo usa anche per print.

Oggetti in una lista e in un dizionario

Gli oggetti si mettono nelle liste e nei dizionari come qualunque altro valore. Con key= scegli quale attributo confrontare.

Python
class Treno:
    def __init__(self, codice, ritardo):
        self.codice = codice
        self.ritardo = ritardo

    def __repr__(self):
        return f"Treno('{self.codice}', {self.ritardo})"


treni = [Treno("T-07", 3), Treno("T-12", 0), Treno("T-03", 12)]

for treno in treni:
    print(treno.codice, treno.ritardo)
# → T-07 3
# → T-12 0
# → T-03 12

[t.codice for t in treni if t.ritardo > 0]  # → ['T-07', 'T-03']
max(treni, key=lambda t: t.ritardo)  # → Treno('T-03', 12)
sorted(treni, key=lambda t: t.ritardo)  # → [Treno('T-12', 0), Treno('T-07', 3), Treno('T-03', 12)]
max(treni)  # → TypeError: '>' not supported between instances of 'Treno' and 'Treno'

per_codice = {t.codice: t for t in treni}
per_codice["T-12"]  # → Treno('T-12', 0)
per_codice["T-12"].ritardo = 6
treni[1].ritardo  # → 6

Senza key, Python non sa quale treno è «più grande» e si ferma. Nella lista e nel dizionario c'è lo stesso oggetto, non una copia: se lo cambi da una parte, lo vedi cambiato anche dall'altra.

Due etichette sullo stesso oggetto

b = a non copia l'oggetto: gli attacca una seconda etichetta. Un cambiamento fatto con un nome si vede anche con l'altro.

Python
class Treno:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0


a = Treno("T-07")
b = a
b.ritardo = 10
a.ritardo  # → 10
a is b  # → True

c = Treno("T-07")
a is c  # → False
a == c  # → False

Treno("T-07") scritto due volte fa due treni diversi, anche se dentro sono uguali. E per una classe normale == si comporta come is: due oggetti distinti non sono uguali finché non lo spieghi tu a Python (oppure usi @dataclass, più sotto). Il disegno delle etichette è nel capitolo Etichette e scatole.

Ereditarietà

Una classe può partire da un'altra e prendere tutto quello che ha: attributi e metodi. class Tram(Mezzo) si legge «un Tram è un Mezzo».

Python
class Mezzo:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0

    def ritarda(self, minuti):
        self.ritardo += minuti

    def annuncio(self):
        return f"{self.codice}: {self.ritardo} minuti di ritardo"


class Tram(Mezzo):
    pass


tram = Tram("TR-2")
tram.ritarda(4)
tram.annuncio()  # → 'TR-2: 4 minuti di ritardo'

Mezzo è la classe madre, Tram la figlia. Tram qui non scrive niente (pass), eppure ha già __init__, ritarda e annuncio. La figlia scrive solo quello che ha in più o di diverso.

super()

Quando la figlia ha un suo __init__, quello della madre non parte più da solo. super().__init__(...) lo chiama: prima la madre prepara la sua parte, poi la figlia aggiunge la sua.

Python
class Mezzo:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0


class Tram(Mezzo):
    def __init__(self, codice, capolinea):
        super().__init__(codice)
        self.capolinea = capolinea


class Bus(Mezzo):
    def __init__(self, codice, capolinea):
        self.capolinea = capolinea


tram = Tram("TR-2", "Vecchia Fiera")
tram.codice  # → 'TR-2'
tram.capolinea  # → 'Vecchia Fiera'
tram.ritardo  # → 0

bus = Bus("B-4", "Piazza Query")
bus.capolinea  # → 'Piazza Query'
bus.ritardo  # → AttributeError: 'Bus' object has no attribute 'ritardo'

Bus ha dimenticato super().__init__(codice): la parte della madre non è mai partita, e codice e ritardo non ci sono. Metti super().__init__(...) come prima riga dell'__init__ della figlia.

Riscrivere un metodo

La figlia può riscrivere un metodo della madre con lo stesso nome: per i suoi oggetti vale la versione nuova. Dentro, con super().nome_del_metodo() puoi usare anche la versione della madre.

Python
class Mezzo:
    def __init__(self, codice):
        self.codice = codice
        self.ritardo = 0

    def annuncio(self):
        return f"{self.codice}: {self.ritardo} minuti di ritardo"


class Tram(Mezzo):
    def annuncio(self):
        return "Tram " + super().annuncio()


class Treno(Mezzo):
    def annuncio(self):
        return f"Attenzione, treno {self.codice} in arrivo"


mezzi = [Mezzo("M-1"), Tram("TR-2"), Treno("T-07")]
for mezzo in mezzi:
    print(mezzo.annuncio())
# → M-1: 0 minuti di ritardo
# → Tram TR-2: 0 minuti di ritardo
# → Attenzione, treno T-07 in arrivo

Lo stesso mezzo.annuncio() fa cose diverse a seconda dell'oggetto: il for non ha bisogno di chiedersi che mezzo ha in mano.

isinstance() con le classi

Risponde alla domanda «questo oggetto è di questa classe?». Tiene conto dell'ereditarietà: un tram è anche un mezzo.

Python
class Mezzo:
    pass


class Tram(Mezzo):
    pass


class Treno(Mezzo):
    pass


tram = Tram()
isinstance(tram, Tram)  # → True
isinstance(tram, Mezzo)  # → True
isinstance(tram, Treno)  # → False
type(tram) == Mezzo  # → False

type(x) == ... guarda solo la classe esatta, e per Python un tram non è «esattamente» un mezzo. Per questo negli if si usa isinstance. Con i tipi di base funziona allo stesso modo: lo trovi in Le funzioni di base.

@dataclass

Per le classi che servono soprattutto a tenere dati, la libreria standard ha @dataclass: scrivi i campi con il loro tipo, e __init__, __repr__ e == li scrive Python per te.

Python
from dataclasses import dataclass


@dataclass
class Fermata:
    nome: str
    linea: str
    accessibile: bool = True


largo = Fermata("Largo Lista", "Menta")
largo  # → Fermata(nome='Largo Lista', linea='Menta', accessibile=True)
largo.nome  # → 'Largo Lista'
largo == Fermata("Largo Lista", "Menta")  # → True
Fermata("Vecchia Fiera", "Menta", accessibile=False)  # → Fermata(nome='Vecchia Fiera', linea='Menta', accessibile=False)
Fermata("Ponte Ciclo")  # → TypeError: Fermata.__init__() missing 1 required positional argument: 'linea'
Fermata(7, 8)  # → Fermata(nome=7, linea=8, accessibile=True)

I campi con un valore di partenza (accessibile: bool = True) vanno dopo quelli senza. Puoi aggiungere metodi come in una classe normale. I tipi scritti dopo i due punti sono solo un'indicazione: Fermata(7, 8) passa senza errori.

Da qui a Pydantic

Nel libro HTTP e API i dati che arrivano da fuori passano da Pydantic, una libreria che si installa con pip (qui non c'è, per questo l'esempio non si esegue). La forma è quasi quella di una dataclass: una classe con i campi e i loro tipi. La differenza è che Pydantic i tipi li controlla, e dove può li converte.

Python
from pydantic import BaseModel


class Ospite(BaseModel):
    nome: str
    eta: int
    abbonato: bool = False


lucia = Ospite(nome="Lucia", eta="34")
lucia.eta            # 34: la stringa "34" è diventata un numero
lucia.abbonato       # False
lucia.model_dump()   # {'nome': 'Lucia', 'eta': 34, 'abbonato': False}
Ospite(nome="Ivo", eta="tanti")   # ValidationError: eta non è un numero intero

class Ospite(BaseModel) è ereditarietà, come class Tram(Mezzo): Ospite prende da BaseModel tutto il lavoro di controllo, e tu scrivi solo i campi. Con Pydantic gli oggetti si creano con i nomi dei campi: Ospite(nome="Lucia", eta=34).