Classi e oggetti, esercizi spiegati
Cinque esempi, una riga alla volta
- 25 minuti di lettura
Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa c'è nelle scatole dopo ogni riga.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi provare ogni esempio in un file .py o su Python Tutor, che disegna le scatole come le disegniamo noi: a sinistra le etichette (Frames), a destra le scatole (Objects).
A · Due ascensori, uno stampo
A Ponte Ciclo e a Piazza Query le banchine stanno sottoterra. Ogni ascensore sa scendere e salire; il piano 0 è la strada.
class Ascensore:
def __init__(self, stazione):
self.stazione = stazione
self.piano = 0
def scendi(self, piani):
self.piano = self.piano - piani
def sali(self, piani):
self.piano = self.piano + piani
ponte = Ascensore("Ponte Ciclo")
query = Ascensore("Piazza Query")
ponte.scendi(3)
query.scendi(1)
ponte.sali(1)
print(ponte.stazione, ponte.piano)
print(query.stazione, query.piano)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Ponte Ciclo -2
Piazza Query -1In italiano.
- Lo stampo dice: ogni ascensore ha una stazione e un piano, che parte da 0.
- Sa scendere (il piano diminuisce) e salire (il piano aumenta).
- Creo due ascensori: due scatole.
- Ogni chiamata muove solo l'ascensore prima del punto.
Passo per passo.
| Riga | Python la legge come | self è | ponte.piano | query.piano |
|---|---|---|---|---|
ponte = Ascensore("Ponte Ciclo") | __init__ su una scatola nuova | la scatola nuova | 0 | — |
query = Ascensore("Piazza Query") | __init__ su un'altra scatola nuova | l'altra scatola | 0 | 0 |
ponte.scendi(3) | Ascensore.scendi(ponte, 3) | ponte | -3 | 0 |
query.scendi(1) | Ascensore.scendi(query, 1) | query | -3 | -1 |
ponte.sali(1) | Ascensore.sali(ponte, 1) | ponte | -2 | -1 |
Il disegno, alla fine.
Cosa portiamo a casa. Uno stampo, due scatole. Un metodo lavora solo sulla scatola prima del punto: dentro scendi, self.piano è il piano di quell'ascensore, e di nessun altro.
B · Il distributore di biglietti
A Largo Lista il distributore ha due biglietti. Ha un metodo che cambia l'oggetto e uno che risponde.
class Distributore:
def __init__(self, stazione, biglietti):
self.stazione = stazione
self.biglietti = biglietti
def vendi(self):
self.biglietti = self.biglietti - 1
def vuoto(self):
return self.biglietti == 0
d = Distributore("Largo Lista", 2)
print(d.vendi())
d.vendi()
print(d.biglietti)
print(d.vuoto())
print(d.vuoto)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
None
0
True
<bound method Distributore.vuoto of <__main__.Distributore object at 0x1023a2870>>- Riga 1:
vendi()vende davvero un biglietto, ma non restituisce niente:printmostraNone. - Riga 2: la seconda vendita. Da 2 biglietti siamo a 0.
- Riga 3:
vuoto()risponde:0 == 0èTrue. - Riga 4: senza parentesi il metodo non parte.
printmostra il metodo stesso: «il metodovuoto, attaccato a quel distributore». Il numero dopo0xcambia a ogni esecuzione.
In italiano.
vendicambia l'oggetto: un biglietto in meno. Non c'èreturn.vuotonon cambia niente: rispondeTrueoFalse, conreturn.
Passo per passo.
| Riga | Cosa fa | d.biglietti dopo | Cosa stampa |
|---|---|---|---|
d = Distributore("Largo Lista", 2) | crea la scatola | 2 | — |
print(d.vendi()) | vende, poi stampa quello che vendi restituisce | 1 | None |
d.vendi() | vende | 0 | — |
print(d.biglietti) | legge l'attributo | 0 | 0 |
print(d.vuoto()) | chiede, e stampa la risposta | 0 | True |
print(d.vuoto) | non chiama niente | 0 | <bound method …> |
Cosa portiamo a casa. Un metodo che cambia si chiama da solo, su una riga. Un metodo che risponde si chiama con le parentesi, dentro un print, un if o un'assegnazione.
C · Il self dimenticato, tre volte
L'altoparlante di Vecchia Fiera, scritto bene, in un file altoparlante.py:
class Altoparlante:
def __init__(self, stazione):
self.stazione = stazione
self.volume = 5
def alza(self, quanto):
self.volume = self.volume + quanto
def annuncia(self, testo):
return f"{self.stazione}: {testo}"
a = Altoparlante("Vecchia Fiera")In italiano. Ogni metodo ha bisogno di self in due posti: nella def, per ricevere la scatola su cui lavorare, e davanti a ogni attributo, per trovarlo dentro quella scatola.
Adesso tre versioni, ognuna con un self in meno e una riga in fondo per provarla. Per ognuna: dà errore? Quale, e su quale riga? Nei traceback, al posto di /…/ vedrai il percorso della tua cartella.
Versione 1. Manca self nella def di alza. In fondo: a.alza(2).
def alza(quanto):
self.volume = self.volume + quantoPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Traceback (most recent call last):
File "/…/altoparlante.py", line 14, in <module>
a.alza(2)
TypeError: Altoparlante.alza() takes 1 positional argument but 2 were givena.alza(2) è Altoparlante.alza(a, 2): Python passa due cose, la scatola e il 2. La def ha un posto solo, quanto. Il conto non torna già alla chiamata: la prima riga del metodo non parte nemmeno.
Versione 2. Manca self. davanti a stazione, in annuncia. In fondo: print(a.annuncia("treno in arrivo")).
def annuncia(self, testo):
return f"{stazione}: {testo}"Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Traceback (most recent call last):
File "/…/altoparlante.py", line 14, in <module>
print(a.annuncia("treno in arrivo"))
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/…/altoparlante.py", line 10, in annuncia
return f"{stazione}: {testo}"
^^^^^^^^
NameError: name 'stazione' is not defined. Did you mean: 'self.stazione'?Questa volta la chiamata va bene, e il metodo parte. L'errore è dentro, alla riga 10: stazione da sola non è niente, la stazione sta nella scatola. Python te lo suggerisce: self.stazione.
Versione 3. Manca self. a sinistra dell'=, in alza. In fondo: a.alza(2) e print(a.volume).
def alza(self, quanto):
volume = self.volume + quantoPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
5Nessun errore. self.volume + quanto fa 7, ma il 7 finisce su un foglietto, volume, che si butta quando alza finisce. Nella scatola il volume resta 5.
Passo per passo. Le tre versioni a confronto:
| Versione | Dove manca self | Cosa succede | Quando te ne accorgi |
|---|---|---|---|
| 1 | nella def | TypeError: … takes 1 positional argument but 2 were given | alla chiamata |
| 2 | davanti a un attributo che leggi | NameError: name 'stazione' is not defined | quando il metodo parte |
| 3 | davanti a un attributo che scrivi | niente: il valore si perde | mai, se non lo controlla un test |
Cosa portiamo a casa. La versione 3 è la peggiore, perché tace. Quando un metodo «non fa niente», guarda per prima cosa la riga con l'=: a sinistra c'è self.?
D · Lo sportello che non si legge
A Porta Codice ci sono due sportelli, chiusi finché qualcuno non li apre.
class Sportello:
def __init__(self, stazione, numero):
self.stazione = stazione
self.numero = numero
self.aperto = False
def apri(self):
self.aperto = True
uno = Sportello("Porta Codice", 1)
due = Sportello("Porta Codice", 2)
due.apri()
print(uno)
print([uno, due])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
<__main__.Sportello object at 0x1037d2840>
[<__main__.Sportello object at 0x1037d2840>, <__main__.Sportello object at 0x1037d2810>]Python non sa come mostrare uno sportello: dice solo che è un oggetto Sportello e dove sta in memoria. I numeri cambiano a ogni esecuzione; i due sportelli hanno numeri diversi perché sono due scatole.
Aggiungiamo alla classe, sotto apri, il metodo __repr__: restituisce il testo che vogliamo vedere. Le righe in fondo restano le stesse.
def __repr__(self):
if self.aperto:
stato = "aperto"
else:
stato = "chiuso"
return f"Sportello {self.numero} di {self.stazione}: {stato}"Il disegno.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Sportello 1 di Porta Codice: chiuso
[Sportello 1 di Porta Codice: chiuso, Sportello 2 di Porta Codice: aperto]In italiano.
- Prima di comporre il testo, decido la parola giusta per lo stato: un
ifsull'attributoaperto. - Restituisco il testo, con
return. - Python lo usa da solo: per
print(uno), e per ogni sportello dentro la lista.
Passo per passo. __repr__ non compare in nessuna riga in fondo al file, eppure parte tre volte:
| Riga | Chi chiede il testo | Python chiama | self è | Il testo |
|---|---|---|---|---|
print(uno) | print | Sportello.__repr__(uno) | uno | Sportello 1 di Porta Codice: chiuso |
print([uno, due]) | la lista, per il primo elemento | Sportello.__repr__(uno) | uno | Sportello 1 di Porta Codice: chiuso |
| la lista, per il secondo elemento | Sportello.__repr__(due) | due | Sportello 2 di Porta Codice: aperto |
Cosa portiamo a casa. __repr__ non lo chiami mai tu: lo chiama Python ogni volta che deve mostrare l'oggetto. Tu decidi solo il testo, e lo restituisci.
E · Le scale mobili di Largo Lista
Le scale mobili di Largo Lista stanno in un dizionario: codice → oggetto. Una si ferma, il tecnico la fa ripartire, un'altra si ferma.
class ScalaMobile:
def __init__(self, codice):
self.codice = codice
self.in_funzione = True
def ferma(self):
self.in_funzione = False
def riparti(self):
self.in_funzione = True
scale = {}
for codice in ["LL-1", "LL-2", "LL-3"]:
scale[codice] = ScalaMobile(codice)
scale["LL-2"].ferma()
da_riparare = scale["LL-2"]
da_riparare.riparti()
scale["LL-3"].ferma()
for codice, scala in scale.items():
print(codice, scala.in_funzione)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
LL-1 True
LL-2 True
LL-3 FalseLL-2 è tornata in funzione, anche se riparti() l'abbiamo chiamato su da_riparare e non su scale["LL-2"]. Sono la stessa scala.
In italiano.
- Per ogni codice creo una scala mobile e la metto nel dizionario, con il codice come chiave.
- Fermo LL-2, prendendola dal dizionario.
- Le attacco un'altra etichetta,
da_riparare, e la faccio ripartire da lì. - Fermo LL-3.
- Scorro il dizionario: codice e scala, e di ogni scala leggo
in_funzione.
Passo per passo.
| Riga | Cosa fa | LL-1 | LL-2 | LL-3 |
|---|---|---|---|---|
il for con ScalaMobile(codice) | tre scatole nuove, tre chiavi | in funzione | in funzione | in funzione |
scale["LL-2"].ferma() | prende la scatola di LL-2 e la ferma | in funzione | ferma | in funzione |
da_riparare = scale["LL-2"] | una seconda etichetta su quella scatola | in funzione | ferma | in funzione |
da_riparare.riparti() | self è la scatola di LL-2 | in funzione | in funzione | in funzione |
scale["LL-3"].ferma() | prende la scatola di LL-3 e la ferma | in funzione | in funzione | ferma |
Il disegno, dopo da_riparare = scale["LL-2"]:
Tre scatole ScalaMobile, quattro frecce. da_riparare non è una copia: è un'altra strada per arrivare alla stessa scala.
Cosa portiamo a casa. scale["LL-2"].ferma() si legge da sinistra a destra: prima il dizionario trova la scatola, poi il metodo lavora su quella. E x = scale["LL-2"] ti dà una seconda etichetta, che è proprio quello che vuoi quando devi cambiare un oggetto che sta nel dizionario: lo cambi da x, e nel dizionario è cambiato.
Pronto? Gli stessi schemi ti aspettano nella palestra: sette classi da completare, con i test.