Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test1. Sette regole per chi leggep. 8

Sette regole, esercizi spiegati

Cinque script di Ivo, un passo alla volta

  • 25 minuti di lettura

Cinque script di Ivo da rimettere in ordine. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi lo script e rispondi alla domanda prima di aprire la risposta.
  2. In italiano: cosa c'è che non va, e cosa si fa.
  3. Passo per passo: il prima, il dopo, e quale test diventa verde.
  4. Cosa portiamo a casa: la cosa da ricordare.

I test di questi esempi sono come quelli della palestra: uno controlla che l'uscita sia identica (il comportamento non cambia) e altri guardano la forma (nomi, numeri, except...). All'inizio quello sul comportamento è verde e quelli sulla forma sono rossi: lavori finché diventano verdi tutti, senza mai far diventare rosso il primo.


A · La capienza dei treni (nomi e numeri magici)

Ivo scrive di notte un controllo: un treno è pieno quando i passeggeri superano i posti.

Python
TRENI_DI_STASERA = [(4, 250), (4, 200)]


def c(v, p):
    t = v * 62
    if p > t:
        return "pieno"
    return "posti liberi"


for v, p in TRENI_DI_STASERA:
    print(c(v, p))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Cosa stampa? Cosa sono c, v, p, t, e cos'è quel 62?

pieno
posti liberi

v sono i vagoni, p i passeggeri, t la capienza totale; 62 sono i posti di un vagone. Quattro vagoni da 62 fanno 248 posti: 250 passeggeri sono troppi, 200 no.

Hai dovuto indovinarlo. Nessun nome te lo diceva.

In italiano. Due difetti, due regole: i nomi dicono poco (regola 1) e il 62 non ha un nome (regola 3). In più c fa due cose: calcola la capienza e decide la scritta (regola 2). Lo sistemiamo a piccoli passi.

Passo per passo.

Il test che controlla la forma ha tre prove: l'uscita identica, nessun nome di una o due lettere, nessun numero senza un nome. Sullo scheletro:

palestra/test_capienza.py::test_stesso_output PASSED                     [ 33%]
palestra/test_capienza.py::test_nessun_nome_corto FAILED                 [ 66%]
palestra/test_capienza.py::test_niente_numeri_magici FAILED              [100%]
E       AssertionError: Nomi troppo corti: ['c', 'p', 't', 'v']
E       AssertionError: Numeri senza un nome (riga, numero): [(5, 62)]
  1. I nomi. c diventa stato_del_treno, v vagoni, p passeggeri, t capienza. Il programma fa la stessa cosa, e il terzo rosso resta:
Python
def stato_del_treno(vagoni, passeggeri):
    capienza = vagoni * 62
    if passeggeri > capienza:
        return "pieno"
    return "posti liberi"
palestra/test_capienza.py::test_stesso_output PASSED                     [ 33%]
palestra/test_capienza.py::test_nessun_nome_corto PASSED                 [ 66%]
palestra/test_capienza.py::test_niente_numeri_magici FAILED              [100%]
E       AssertionError: Numeri senza un nome (riga, numero): [(5, 62)]
  1. Il numero. Il 62 diventa POSTI_PER_VAGONE, in cima al file. E visto che ci siamo, il calcolo della capienza e la decisione diventano due funzioni con un compito ciascuna:
Python
TRENI_DI_STASERA = [(4, 250), (4, 200)]
POSTI_PER_VAGONE = 62


def treno_pieno(vagoni: int, passeggeri: int) -> bool:
    capienza = vagoni * POSTI_PER_VAGONE
    return passeggeri > capienza


def stato_del_treno(vagoni: int, passeggeri: int) -> str:
    if treno_pieno(vagoni, passeggeri):
        return "pieno"
    return "posti liberi"


for vagoni, passeggeri in TRENI_DI_STASERA:
    print(stato_del_treno(vagoni, passeggeri))
palestra/test_capienza.py::test_stesso_output PASSED                     [ 33%]
palestra/test_capienza.py::test_nessun_nome_corto PASSED                 [ 66%]
palestra/test_capienza.py::test_niente_numeri_magici PASSED              [100%]
============================== 3 passed in 0.02s ===============================

E il programma stampa ancora pieno e posti liberi.

Cosa portiamo a casa. Un cambiamento alla volta, un test che torna verde. E i nomi servono anche a spezzare una funzione: quando trovi il nome giusto per un pezzo, quel pezzo è già una funzione.


B · La media dei ritardi (una funzione, un compito, due file)

Ivo vuole la media dei ritardi della giornata. La funzione calcola e stampa.

Python
def media_e_stampa(minuti):
    totale = 0
    for ritardo in minuti:
        totale = totale + ritardo
    media = totale / len(minuti)
    print(f"Media dei ritardi: {media:.1f} minuti")


media_e_stampa([2, 0, 7, 11])
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Cosa stampa? E se Marta volesse solo la media, senza la scritta, per usarla in un altro punto del programma?

Media dei ritardi: 5.0 minuti

Non può: la funzione stampa sempre, e non restituisce niente. Per riusare il conto dovrebbe copiarlo.

In italiano. «Calcola la media e la stampa»: c'è una «e», quindi sono due compiti. Il calcolo si mette in un modulo suo, che restituisce il risultato; la scritta la fa chi stampa, in un altro file che importa il primo.

Passo per passo.

Tre test: l'uscita identica; il modulo del calcolo non contiene print; chi stampa importa il calcolo. Sullo scheletro:

palestra/test_ritardi.py::test_stesso_output PASSED                      [ 33%]
palestra/test_ritardi.py::test_il_modulo_del_calcolo_non_stampa FAILED   [ 66%]
palestra/test_ritardi.py::test_chi_stampa_importa_il_calcolo FAILED      [100%]
E       AssertionError: Non trovo ritardi_calcolo.py: il file deve restare con questo nome
E       AssertionError: ritardi_stampa.py non importa il calcolo

Il primo rosso dice proprio cosa manca: un file. Lo creiamo:

Python
# ritardi_calcolo.py
def media_ritardo(minuti: list[int]) -> float:
    totale = 0
    for ritardo in minuti:
        totale = totale + ritardo
    return totale / len(minuti)

E il programma che stampa, nel suo file, lo importa (import e from … import li conosci da Moduli e file):

Python
# ritardi_stampa.py
from ritardi_calcolo import media_ritardo

RITARDI_DI_OGGI = [2, 0, 7, 11]

media = media_ritardo(RITARDI_DI_OGGI)
print(f"Media dei ritardi: {media:.1f} minuti")
palestra/test_ritardi.py::test_stesso_output PASSED                      [ 33%]
palestra/test_ritardi.py::test_il_modulo_del_calcolo_non_stampa PASSED   [ 66%]
palestra/test_ritardi.py::test_chi_stampa_importa_il_calcolo PASSED      [100%]
============================== 3 passed in 0.02s ===============================

Lanciando python ritardi_stampa.py:

Media dei ritardi: 5.0 minuti

Cosa portiamo a casa. Chi calcola restituisce, chi stampa stampa. Ora media_ritardo si può provare da sola, e riusare ovunque.


C · I biglietti venduti (gli errori non si nascondono)

Ivo somma i biglietti venduti da una lista di righe «stazione,numero». Per non fermarsi davanti a una riga rotta ha scritto except: pass. Ma stanotte ha anche scritto male un nome.

Python
def biglietti_venduti(righe):
    totale = 0
    for riga in righe:
        try:
            totale = totale + int(riga.splt(",")[1])
        except:
            pass
    return totale


print(biglietti_venduti(["Porta Codice,120", "Largo Lista,80"]))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Le due righe sono giuste: 120 + 80 = 200. Cosa stampa lo script?

0

0, e nessun errore. riga.splt è un nome sbagliato (doveva essere split), che avrebbe fermato il programma con un AttributeError. Ma l'except: da solo ha preso anche quello, e pass l'ha buttato via. Il totale resta a zero, e Ivo penserà che nessuno ha comprato un biglietto.

In italiano. L'except prende ogni errore: quello previsto (una riga rotta) e quello imprevisto (un bug). Si cambia in except ValueError:, che è quello che ci aspettiamo da int("molti"), e dentro si scrive un avviso invece di pass.

Prima di correggere il nome, vediamo cosa cambia con il solo tipo giusto:

AttributeError: 'str' object has no attribute 'splt'. Did you mean: 'split'?

Adesso il bug fa rumore: il programma si ferma, la riga dice quale nome, e Python suggerisce anche la correzione. Quello che nel primo caso era un totale sbagliato, ora è un errore da leggere in dieci secondi.

Passo per passo. Con il nome corretto (split) e una riga davvero rotta (molti), i test sono tre: lo stdout identico, nessun except che nasconde, l'avviso su stderr.

Python
def biglietti_venduti(righe):
    totale = 0
    for riga in righe:
        try:
            totale = totale + int(riga.split(",")[1])
        except:
            pass
    return totale


print(biglietti_venduti(["Porta Codice,120", "Largo Lista,molti", "Ponte Ciclo,80"]))
palestra/test_biglietti.py::test_stdout_uguale PASSED                    [ 33%]
palestra/test_biglietti.py::test_nessun_except_che_nasconde FAILED       [ 66%]
palestra/test_biglietti.py::test_la_riga_rotta_si_dice_su_stderr FAILED  [100%]
E       AssertionError: Except che fanno sparire gli errori (riga, perché): [(6, 'except da solo: prende tutti gli errori, anche i bug')]

Il primo test è verde: l'output (200) è giusto. Gli altri due sono rossi, ed è la forma. La correzione:

Python
import sys


def biglietti_venduti(righe):
    totale = 0
    for numero_riga, riga in enumerate(righe, start=1):
        try:
            totale = totale + int(riga.split(",")[1])
        except ValueError:
            print(f"Riga {numero_riga} ignorata: {riga}", file=sys.stderr)
    return totale


print(biglietti_venduti(["Porta Codice,120", "Largo Lista,molti", "Ponte Ciclo,80"]))

Il disegno.

inizio biglietti_venduti(righe) totale = 0 per ogni numero_riga, riga in righe se int() dà ValueError sì: mostra Riga ignorata (stderr) no: totale = totale + biglietti restituisci totalebiglietti_venduti(righe)totale = 0per ogni numero_riga, rigain righeint() dà ValueErrortotale = totale + bigliettimostra Riga ignorata(stderr)restituisci totalenosìfiniti
Il ciclo con l'avviso
palestra/test_biglietti.py::test_stdout_uguale PASSED                    [ 33%]
palestra/test_biglietti.py::test_nessun_except_che_nasconde PASSED       [ 66%]
palestra/test_biglietti.py::test_la_riga_rotta_si_dice_su_stderr PASSED  [100%]
============================== 3 passed in 0.03s ===============================

Quello che stampa su schermo, con le due uscite insieme:

Riga 2 ignorata: Largo Lista,molti
200

L'avviso va su stderr, il risultato su stdout: così, se il risultato finisce in un file, l'avviso resta a video. È la distinzione che conosci da Moduli e file.

Una cosa in più, quando la funzione non deve decidere da sola. Una funzione che riceve un valore impossibile segnala, e lascia scegliere a chi l'ha chiamata:

Python
PREZZO_PER_ZONA = 1.1


def prezzo_corsa(zone: int) -> float:
    if zone < 1:
        raise ValueError(f"Le zone sono almeno 1, non {zone}")
    return zone * PREZZO_PER_ZONA


print(prezzo_corsa(2))
print(prezzo_corsa(0))
2.2

e poi il programma si ferma, con la riga finale del traceback:

ValueError: Le zone sono almeno 1, non 0

Cosa portiamo a casa. except: da solo e pass dentro un except sono sempre un campanello. O gestisci l'errore che ti aspetti e lo dici (stderr), o lo segnali con raise. Mai farlo sparire.


D · Le salite alle fermate (non ripeterti)

Ivo conta quante persone salgono a Porta Codice e a Largo Lista. Ha scritto il pezzo per la prima, poi l'ha copiato per la seconda.

Python
SALITI = [("Porta Codice", 12), ("Largo Lista", 7), ("Porta Codice", 5), ("Ponte Ciclo", 9)]

salite_porta_codice = 0
for stazione, persone in SALITI:
    if stazione == "Porta Codice":
        salite_porta_codice = salite_porta_codice + persone
print("Porta Codice:", salite_porta_codice)

salite_largo_lista = 0
for stazione, persone in SALITI:
    if stazione == "Largo Lista":
        salite_largo_lista = salite_largo_lista + persone
print("Largo Lista:", salite_largo_lista)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Cosa stampa? E quanto cambierebbe da fare se Marta volesse una terza stazione?

Porta Codice: 17
Largo Lista: 7

Per una terza stazione: un altro blocco, copiato per la terza volta, con tre punti da cambiare (due nomi di variabile e la stazione). Basta dimenticarne uno.

In italiano. Il blocco è lo stesso, cambia solo il nome della stazione. Quel nome diventa un parametro di una funzione, e le due chiamate diventano un ciclo sulla lista dei nomi.

Passo per passo. Due test: uscita identica e nessun pezzo copiato e incollato. Sullo scheletro:

palestra/test_fermate.py::test_stesso_output PASSED                      [ 50%]
palestra/test_fermate.py::test_nessun_blocco_copiato_e_incollato FAILED  [100%]
E       AssertionError: Pezzi quasi uguali (riga del primo, riga del secondo): [(3, 9)]

Il test dice dove: i pezzi alle righe 3 e 9. Il dopo:

Python
SALITI = [("Porta Codice", 12), ("Largo Lista", 7), ("Porta Codice", 5), ("Ponte Ciclo", 9)]


def salite_alla_stazione(salite: list[tuple[str, int]], nome: str) -> int:
    totale = 0
    for stazione, persone in salite:
        if stazione == nome:
            totale = totale + persone
    return totale


for nome in ["Porta Codice", "Largo Lista"]:
    print(f"{nome}: {salite_alla_stazione(SALITI, nome)}")

Il disegno.

inizio salite_alla_stazione(salite, nome) totale = 0 per ogni stazione, persone in salite se stazione == nome sì: totale = totale + persone restituisci totalesalite_alla_stazione(salite,nome)totale = 0per ogni stazione, personein salitestazione == nometotale = totale + personerestituisci totalenosìfiniti
Il conteggio per stazione
palestra/test_fermate.py::test_stesso_output PASSED                      [ 50%]
palestra/test_fermate.py::test_nessun_blocco_copiato_e_incollato PASSED  [100%]
============================== 2 passed in 0.02s ===============================

Una terza stazione adesso è una parola in più nella lista.

Cosa portiamo a casa. Cosa cambia fra i due pezzi? Quello che cambia è un parametro; quello che resta uguale è la funzione. E se la ripetizione è su una lista di cose, di solito è un ciclo.


E · Il ritardo medio (la forma, con Ruff)

L'ultimo script di Ivo funziona, ma è impaginato a caso e non ha tipi.

Python
import os
import sys


def ritardo_medio(minuti,giorni):
    l = [m for m in minuti]
    if giorni == None: return 0
    totale=sum(l)
    return totale/giorni
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Quante cose non va secondo Ruff? Poi, dopo ruff format, quante ne restano?

Il linter ne trova 8:

orari_ivo.py:1:8: F401 [*] `os` imported but unused
orari_ivo.py:2:8: F401 [*] `sys` imported but unused
orari_ivo.py:5:5: ANN201 Missing return type annotation for public function `ritardo_medio`
orari_ivo.py:5:19: ANN001 Missing type annotation for function argument `minuti`
orari_ivo.py:5:26: ANN001 Missing type annotation for function argument `giorni`
orari_ivo.py:6:5: E741 Ambiguous variable name: `l`
orari_ivo.py:7:18: E711 Comparison to `None` should be `cond is None`
orari_ivo.py:7:22: E701 Multiple statements on one line (colon)
Found 8 errors.
[*] 2 fixable with `--fix` (1 unsafe fix available with `--fix --unsafe-fixes`).

Il formattatore ne sistema una (la E701: l'if e il return sulla stessa riga). Le altre sono scelte tue.

In italiano. Due strumenti, due mestieri. ruff format cambia l'impaginazione; ruff check segnala. Si comincia dal formattatore, perché dopo l'impaginazione le segnalazioni sono più leggibili:

Terminale
ruff format orari_ivo.py
1 file reformatted

Passo per passo. Dopo ruff format il file è:

Python
import os
import sys


def ritardo_medio(minuti, giorni):
    l = [m for m in minuti]
    if giorni == None:
        return 0
    totale = sum(l)
    return totale / giorni

Rilanciamo ruff check: la E701 non c'è più, ne restano 7.

orari_ivo.py:1:8: F401 [*] `os` imported but unused
orari_ivo.py:2:8: F401 [*] `sys` imported but unused
orari_ivo.py:5:5: ANN201 Missing return type annotation for public function `ritardo_medio`
orari_ivo.py:5:19: ANN001 Missing type annotation for function argument `minuti`
orari_ivo.py:5:27: ANN001 Missing type annotation for function argument `giorni`
orari_ivo.py:6:5: E741 Ambiguous variable name: `l`
orari_ivo.py:7:18: E711 Comparison to `None` should be `cond is None`
Found 7 errors.
[*] 2 fixable with `--fix` (1 unsafe fix available with `--fix --unsafe-fixes`).

Restano da correggere a mano, una per una:

SegnalazioneLa correzione
F401 (os, sys)Cancella i due import che non usi
E741l è un nome ambiguo (somiglia a 1) e comunque è una copia inutile di minuti: si somma direttamente minuti
E711giorni == None diventa giorni is None: con None si confronta con is
ANN001, ANN201I tipi: list[int] per minuti, float per quello che restituisce, e per giorni «un numero oppure niente», che si scrive come vedi nel codice qui sotto

Il risultato:

Python
def ritardo_medio(minuti: list[int], giorni: int | None) -> float:
    if giorni is None:
        return 0
    return sum(minuti) / giorni

Rilanciando ruff check e ruff format --check:

All checks passed!
1 file already formatted

In VS Code puoi anche lasciare l'estensione fare il lavoro: sottolinea mentre scrivi, e Format Document (Shift+Option+F su Mac, Shift+Alt+F su Windows) impagina.

Cosa portiamo a casa. Prima ruff format, poi ruff check. Il formattatore decide la faccia del file; il linter ti dice quali scelte sono da rivedere. Nessuno dei due cambia quello che il programma fa.


Pronto? Le stesse sette regole ti aspettano nella palestra: sette esercizi da scaricare, uno per regola, con i test.