Vai al contenuto
code-to-code

Apro l'indice…

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

Python9. Classi e oggettip. 265

Classi e oggetti

Lo stampo, le scatole, e self

  • 12 minuti di lettura

Fin qui un treno era un dizionario: {"codice": "M12", "vagoni": 4}. I dati ci sono. Ma quello che un treno sa fare (partire, agganciare vagoni, presentarsi) sta da un'altra parte, in funzioni sparse che ricevono il dizionario e sperano che le chiavi siano scritte giuste.

Una classe mette insieme le due cose: i dati di un treno e quello che un treno sa fare.

Gli oggetti, in realtà, li usi da giorni:

Python
"porta codice".upper()          # una stringa sa diventare maiuscola
fermate.append("Largo Lista")   # una lista sa allungarsi
vagoni.get("M14")               # un dizionario sa cercare una chiave

Il punto collega un oggetto a qualcosa che sa fare, un metodo (con le parentesi), oppure a qualcosa che ha, un attributo (senza parentesi). In questo capitolo scrivi i tuoi.

Lo stampo e le scatole

La classe è lo stampo: dice com'è fatto ogni treno e cosa sa fare. Da sola non è un treno.

Un oggetto è una cosa fatta con lo stampo: un treno vero, con i suoi dati. Con uno stampo fai quanti oggetti vuoi: stessa forma, dati diversi.

Il disegno

Lo disegniamo come in Etichette e scatole. In alto lo stampo; sotto, etichette a sinistra, scatole a destra. Ogni oggetto è una scatola, e dentro ci sono i suoi attributi.

LA CLASSE (lo stampo)

  Treno
    ha:       codice · vagoni · in_corsa
    sa fare:  parti() · aggancia(quanti) · descrivi()
m12 = Treno(codice="M12", vagoni=4, in_corsa=False) m14 = Treno(codice="M14", vagoni=3, in_corsa=False)m12m14Trenocodice"M12"vagoni4in_corsaFalseTrenocodice"M14"vagoni3in_corsaFalse
Uno stampo, due scatole

Uno stampo, due scatole. Ogni scatola ha i suoi attributi: se agganci vagoni a m12, quelli di m14 non si muovono.

Com'è fatta una classe

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

    def parti(self):
        self.in_corsa = True

    def aggancia(self, quanti):
        self.vagoni = self.vagoni + quanti

    def descrivi(self):
        return f"{self.codice}, {self.vagoni} vagoni"

Riga per riga:

  1. class Treno: è il nome dello stampo, con la maiuscola. Treno è la classe; treno, minuscolo, sarà un oggetto.
  2. __init__ prepara ogni oggetto nuovo: riempie la scatola. Parte da solo, quando crei un treno.
  3. self.codice = codice: a sinistra il posto nella scatola, a destra il valore che arriva da fuori.
  4. self.in_corsa = False non arriva da fuori: ogni treno nuovo parte fermo.
  5. parti, aggancia e descrivi sono i metodi: funzioni scritte dentro la classe. Ricevono sempre self per primo.

Nei file della palestra i metodi hanno anche i type hints del capitolo Le funzioni, per esempio def aggancia(self, quanti: int) -> None:. A self il tipo non si mette. E -> None ti dice già una cosa: quel metodo cambia l'oggetto e non restituisce niente.

Creare un oggetto, in tre fotogrammi

m12 = Treno("M12", 4). Chiamare la classe come una funzione crea un oggetto. Succede in tre tempi:

1 · Python crea una scatola vuota, a forma di Treno

         ┌─ Treno ──────────────┐
         │       (vuota)        │
         └──────────────────────┘

2 · Chiama __init__: self è attaccato alla scatola nuova,
    codice vale "M12", vagoni vale 4

self ──▶ ┌─ Treno ──────────────┐
         │ codice     "M12"     │
         │ vagoni     4         │
         │ in_corsa   False     │
         └──────────────────────┘

3 · __init__ finisce, self si stacca, arriva l'etichetta m12

m12  ──▶ ┌─ Treno ──────────────┐
         │ codice     "M12"     │
         │ vagoni     4         │
         │ in_corsa   False     │
         └──────────────────────┘

I valori tra parentesi vanno a __init__ dopo self: "M12" in codice, 4 in vagoni. self non lo passi mai tu: lo mette Python, ed è la scatola nuova.

self è l'oggetto prima del punto

Dentro un metodo, self è l'oggetto su cui stai lavorando. Quale? Quello prima del punto.

Python
m12.aggancia(2)     # Python lo legge come  Treno.aggancia(m12, 2)
m14.parti()         # Python lo legge come  Treno.parti(m14)

Non è un modo di dire: puoi scriverlo davvero, e fa la stessa cosa.

Python
Treno.parti(m14)
print(m14.in_corsa)      # True
m12.aggancia(2)   è   Treno.aggancia(m12, 2)

                 ┌─ Treno ──────────────┐
m12  ─────────▶  │ codice     "M12"     │ ◀── self
                 │ vagoni     4 → 6     │
                 └──────────────────────┘

                 ┌─ Treno ──────────────┐
m14  ─────────▶  │ codice     "M14"     │
                 │ vagoni     3         │     (nessuno la tocca)
                 └──────────────────────┘

Lo stesso metodo, su due oggetti: ogni volta self è attaccato alla scatola prima del punto. Per questo self.vagoni vuol dire «i vagoni di questo treno».

Due tipi di metodi: cambiare o rispondere

Quasi ogni metodo è di uno di questi due tipi.

Cambia l'oggettoRisponde con un valore
Esempiparti(), aggancia(2)descrivi()
Dentro c'èself.qualcosa = …return …
RestituisceNoneil valore
Si chiama cosìda solo, su una riga: m12.aggancia(2)dentro un'altra riga: testo = m12.descrivi()
Python
m12 = Treno("M12", 4)
m12.parti()
m12.aggancia(2)
print(m12.vagoni, m12.in_corsa)     # 6 True
print(m12.descrivi())               # M12, 6 vagoni

Attento anche alle parentesi. Un metodo senza parentesi non parte: print(m12.descrivi) stampa <bound method Treno.descrivi of …>, il metodo invece del suo risultato. E un attributo con le parentesi si arrabbia: m12.vagoni() dà TypeError: 'int' object is not callable.

Il self dimenticato

È l'errore più comune del capitolo, e ha tre facce.

Manca nella def. Il metodo non ha posto per la scatola:

Python
    def aggancia(quanti):                       # manca self
        self.vagoni = self.vagoni + quanti
TypeError: Treno.aggancia() takes 1 positional argument but 2 were given

Leggilo così: con m12.aggancia(2) Python passa due cose, la scatola m12 e il 2; la def ha posto per una.

Manca davanti a un attributo che leggi. Dentro il metodo, codice da solo è un'etichetta del metodo, e non esiste. Il codice sta nella scatola: self.codice.

Python
    def descrivi(self):
        return f"{codice}, {self.vagoni} vagoni"      # manca self.
NameError: name 'codice' is not defined. Did you mean: 'self.codice'?

Python 3.12 te lo suggerisce pure.

Manca davanti a un attributo che scrivi. È la più subdola, perché lì per lì non succede niente.

Python
    def __init__(self, codice, vagoni):
        codice = codice                          # manca self.
        self.vagoni = vagoni
        self.in_corsa = False

codice = codice attacca un'etichetta su un foglietto che vive solo dentro __init__. Quando __init__ finisce, il foglietto si butta, e nella scatola il codice non c'è.

dentro __init__                 la scatola di m12, dopo

codice ──▶ "M12"                ┌─ Treno ──────────────┐
(buttato via alla fine)         │ vagoni     4         │
                                │ in_corsa   False     │
                                └──────────────────────┘

L'errore arriva dopo, quando qualcuno cerca il codice: AttributeError: 'Treno' object has no attribute 'codice'. In un metodo è anche peggio: con vagoni = self.vagoni + quanti non arriva nessun errore, e i vagoni restano quelli di prima.

Per vedere il buco, guarda dentro la scatola. vars ti mostra gli attributi di un oggetto come un dizionario, nome → valore:

Python
m12 = Treno("M12", 4)        # con il __init__ sbagliato di qui sopra
print(vars(m12))
{'vagoni': 4, 'in_corsa': False}

Il codice non c'è. Con il __init__ giusto, e dopo parti() e aggancia(2), avresti visto {'codice': 'M12', 'vagoni': 6, 'in_corsa': True}.

Stampare bene: __repr__

Python
print(m12)
<__main__.Treno object at 0x1078c36b0>

Python sa solo che è un Treno e dove sta in memoria (quel numero cambia ogni volta). Come mostrarlo glielo dici tu, con un altro metodo speciale, __repr__: restituisce il testo che vuoi vedere.

Python
class Treno:
    # … __init__ e gli altri metodi, come prima …

    def __repr__(self):
        return f"Treno {self.codice}, {self.vagoni} vagoni"
Python
m12 = Treno("M12", 4)
m14 = Treno("M14", 3)
print(m12)           # Treno M12, 4 vagoni
print([m12, m14])    # [Treno M12, 4 vagoni, Treno M14, 3 vagoni]

Python lo usa dappertutto: con print, dentro le liste e i dizionari, nei messaggi di pytest quando un test è rosso.

Oggetti in liste e dizionari

Un oggetto è un valore come gli altri: sta in una lista, sta in un dizionario.

Python
flotta = [Treno("M12", 4), Treno("M14", 3), Treno("M16", 6)]
for treno in flotta:
    treno.aggancia(1)          # a ogni giro, self è un treno diverso
print(flotta)
[Treno M12, 5 vagoni, Treno M14, 4 vagoni, Treno M16, 7 vagoni]

Il deposito è lo schema «indicizzare» del capitolo I dizionari, con gli oggetti al posto dei dizionari: codice → treno.

Python
deposito = {}
for treno in flotta:
    deposito[treno.codice] = treno     # la chiave è un attributo del valore

deposito["M14"].parti()
print(deposito["M14"].in_corsa)        # True

Si legge da sinistra a destra, una scatola alla volta: deposito["M14"] è il treno, .parti() lavora su quello.

flotta = [Treno(codice="M12", vagoni=5, in_corsa=False), Treno(codice="M14", vagoni=4, in_corsa=True), Treno(codice="M16", vagoni=7, in_corsa=False)] deposito = {"M12": flotta[0], "M14": flotta[1], "M16": flotta[2]}flottadepositolist012Trenocodice"M12"vagoni5in_corsaFalseTrenocodice"M14"vagoni4in_corsaTrueTrenocodice"M16"vagoni7in_corsaFalsedict"M12""M14""M16"
Tre treni, una lista e un dizionario

Le scatole Treno sono tre, non sei: la lista e il dizionario puntano agli stessi treni. Per questo adesso anche flotta[1].in_corsa vale True.

Due etichette, una scatola

= non copia un oggetto: attacca una seconda etichetta alla stessa scatola. È lo stesso treno, chiamato in due modi.

Python
m12 = Treno("M12", 4)
riserva = m12
riserva.aggancia(2)
print(m12.vagoni)          # 6
m12 = Treno(codice="M12", vagoni=6, in_corsa=False) riserva = m12m12riservaTrenocodice"M12"vagoni6in_corsaFalse
Due etichette, un treno

Conta le scatole, non le etichette: qui la scatola è una. Per avere un secondo treno serve una seconda chiamata a Treno(...). Ne parla per intero il capitolo Etichette e scatole.

Verso FastAPI: la classe diventa un modello

Con Pydantic hai scritto classi così:

Python
from pydantic import BaseModel


class Treno(BaseModel):
    codice: str
    vagoni: int

È lo stesso stampo di questa pagina, senza __init__: lo scrive BaseModel per te, leggendo i campi e i loro tipi. In più controlla i dati: con Treno(codice="M12", vagoni="4") i vagoni diventano il numero 4; con vagoni="tanti" si ferma con un ValidationError, che in FastAPI diventa il 422.

Il resto lo sai già. Gli oggetti si creano con i nomi dei campi (codice="M12"), gli attributi si leggono con il punto (m12.vagoni), ogni treno è la sua scatola. Le parentesi dopo il nome, (BaseModel), sono l'ereditarietà: è il capitolo dopo, L'ereditarietà. I modelli, campo per campo: Pydantic.

Ricorda

  • La classe è lo stampo, l'oggetto è una scatola fatta con lo stampo. Treno("M12", 4) crea la scatola e chiama __init__ per riempirla.
  • self è l'oggetto su cui stai lavorando, quello prima del punto: m12.parti() è Treno.parti(m12).
  • Dentro la classe: self primo parametro di ogni metodo, self. davanti a ogni attributo.
  • Un metodo cambia l'oggetto (e restituisce None) oppure risponde con return.
  • __repr__ decide come si vede un oggetto; vars(oggetto) ti mostra cosa c'è dentro.
  • = non copia un oggetto: attacca un'altra etichetta alla stessa scatola.