Vai al contenuto
code-to-code

Apro l'indice…

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

Python9. Classi e oggettip. 271

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:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
  2. In italiano: cosa fa il programma, a parole.
  3. Passo per passo: cosa c'è nelle scatole dopo ogni riga.
  4. 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.

Python
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 -1

In italiano.

  1. Lo stampo dice: ogni ascensore ha una stazione e un piano, che parte da 0.
  2. Sa scendere (il piano diminuisce) e salire (il piano aumenta).
  3. Creo due ascensori: due scatole.
  4. Ogni chiamata muove solo l'ascensore prima del punto.

Passo per passo.

RigaPython la legge comeself èponte.pianoquery.piano
ponte = Ascensore("Ponte Ciclo")__init__ su una scatola nuovala scatola nuova0—
query = Ascensore("Piazza Query")__init__ su un'altra scatola nuoval'altra scatola00
ponte.scendi(3)Ascensore.scendi(ponte, 3)ponte-30
query.scendi(1)Ascensore.scendi(query, 1)query-3-1
ponte.sali(1)Ascensore.sali(ponte, 1)ponte-2-1

Il disegno, alla fine.

ponte = Ascensore(stazione="Ponte Ciclo", piano=-2) query = Ascensore(stazione="Piazza Query", piano=-1)pontequeryAscensorestazione"Ponte Ciclo"piano-2Ascensorestazione"Piazza Query"piano-1
Alla fine, due scatole

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.

Python
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: print mostra None.
  • 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. print mostra il metodo stesso: «il metodo vuoto, attaccato a quel distributore». Il numero dopo 0x cambia a ogni esecuzione.

In italiano.

  1. vendi cambia l'oggetto: un biglietto in meno. Non c'è return.
  2. vuoto non cambia niente: risponde True o False, con return.

Passo per passo.

RigaCosa fad.biglietti dopoCosa stampa
d = Distributore("Largo Lista", 2)crea la scatola2—
print(d.vendi())vende, poi stampa quello che vendi restituisce1None
d.vendi()vende0—
print(d.biglietti)legge l'attributo00
print(d.vuoto())chiede, e stampa la risposta0True
print(d.vuoto)non chiama niente0<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:

Python
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).

Python
    def alza(quanto):
        self.volume = self.volume + quanto
Prevedi 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 given

a.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")).

Python
    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).

Python
    def alza(self, quanto):
        volume = self.volume + quanto
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
5

Nessun 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:

VersioneDove manca selfCosa succedeQuando te ne accorgi
1nella defTypeError: … takes 1 positional argument but 2 were givenalla chiamata
2davanti a un attributo che leggiNameError: name 'stazione' is not definedquando il metodo parte
3davanti a un attributo che scriviniente: il valore si perdemai, 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.

Python
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.

Python
    def __repr__(self):
        if self.aperto:
            stato = "aperto"
        else:
            stato = "chiuso"
        return f"Sportello {self.numero} di {self.stazione}: {stato}"

Il disegno.

inizio __repr__(self) se self.aperto sì: stato = "aperto" no: stato = "chiuso" restituisci "Sportello numero di stazione: stato"__repr__(self)self.apertostato = "chiuso"stato = "aperto"restituisci "Sportellonumero di stazione: stato"nosì
Il testo di __repr__
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.

  1. Prima di comporre il testo, decido la parola giusta per lo stato: un if sull'attributo aperto.
  2. Restituisco il testo, con return.
  3. 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:

RigaChi chiede il testoPython chiamaself èIl testo
print(uno)printSportello.__repr__(uno)unoSportello 1 di Porta Codice: chiuso
print([uno, due])la lista, per il primo elementoSportello.__repr__(uno)unoSportello 1 di Porta Codice: chiuso
la lista, per il secondo elementoSportello.__repr__(due)dueSportello 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.

Python
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 False

LL-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.

  1. Per ogni codice creo una scala mobile e la metto nel dizionario, con il codice come chiave.
  2. Fermo LL-2, prendendola dal dizionario.
  3. Le attacco un'altra etichetta, da_riparare, e la faccio ripartire da lì.
  4. Fermo LL-3.
  5. Scorro il dizionario: codice e scala, e di ogni scala leggo in_funzione.

Passo per passo.

RigaCosa faLL-1LL-2LL-3
il for con ScalaMobile(codice)tre scatole nuove, tre chiaviin funzionein funzionein funzione
scale["LL-2"].ferma()prende la scatola di LL-2 e la fermain funzionefermain funzione
da_riparare = scale["LL-2"]una seconda etichetta su quella scatolain funzionefermain funzione
da_riparare.riparti()self è la scatola di LL-2in funzionein funzionein funzione
scale["LL-3"].ferma()prende la scatola di LL-3 e la fermain funzionein funzioneferma

Il disegno, dopo da_riparare = scale["LL-2"]:

scale = {"LL-1": ScalaMobile(codice="LL-1", in_funzione=True), "LL-2": ScalaMobile(codice="LL-2", in_funzione=False), "LL-3": ScalaMobile(codice="LL-3", in_funzione=True)} da_riparare = scale["LL-2"]scaleda_ripararedict"LL-1""LL-2""LL-3"ScalaMobilecodice"LL-1"in_funzioneTrueScalaMobilecodice"LL-2"in_funzioneFalseScalaMobilecodice"LL-3"in_funzioneTrue
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.