Rifattorizzare, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: rifattorizzare ha molte strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano quasi tutti i test e si rompono su uno solo.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · I passaggi ai tornelli
In italiano. Il programma fa quattro cose, e ognuna diventa una funzione.
- Leggo il file e spezzo ogni riga.
- Conto, per ogni stazione, le entrate, le uscite e i passaggi di ogni ora.
- Dai passaggi di ogni ora ricavo l'ora di punta.
- Stampo una riga per stazione, e il totale.
La main è l'indice: legge, conta, stampa.
def leggi_passaggi(percorso: str) -> list[list[str]]:
with open(percorso, encoding="utf-8") as file:
righe = file.readlines()[1:]
return [riga.strip().split(",") for riga in righe]
def conta_per_stazione(passaggi: list[list[str]]) -> dict[str, dict]:
stazioni = {}
for stazione, ora, verso in passaggi:
if stazione not in stazioni:
stazioni[stazione] = {"entrate": 0, "uscite": 0, "per_ora": {}}
if verso == "entrata":
stazioni[stazione]["entrate"] += 1
else:
stazioni[stazione]["uscite"] += 1
per_ora = stazioni[stazione]["per_ora"]
per_ora[ora[:2]] = per_ora.get(ora[:2], 0) + 1
return stazioni
def ora_di_punta(per_ora: dict[str, int]) -> str:
punta = ""
massimo = 0
for ora, passaggi in per_ora.items():
if passaggi > massimo:
massimo = passaggi
punta = ora
return punta
def stampa_stazione(nome: str, conti: dict) -> None:
punta = ora_di_punta(conti["per_ora"])
print(
f"{nome}: {conti['entrate']} entrate, {conti['uscite']} uscite, "
f"ora di punta {punta}"
)
def main(argomenti: list[str]) -> int:
passaggi = leggi_passaggi(argomenti[1])
stazioni = conta_per_stazione(passaggi)
for nome, conti in stazioni.items():
stampa_stazione(nome, conti)
print(f"Totale: {len(passaggi)} passaggi")
return 0Il disegno.
In fondo al file, come sempre, if __name__ == "__main__": sys.exit(main(sys.argv)).
Passo per passo. L'ordine in cui conviene farlo, un commit per riga:
| Passo | Cosa cambi | pytest |
|---|---|---|
| 1 | I nomi, con F2 (d in stazioni, p in pezzi…) | resta verde |
| 2 | Il pezzo che stampa, in stampa_stazione | resta verde |
| 3 | Il ciclo dell'ora di punta, in ora_di_punta | resta verde |
| 4 | Il conteggio, in conta_per_stazione | resta verde |
| 5 | La lettura, in leggi_passaggi | resta verde |
| 6 | Quello che resta diventa main, con il blocco if __name__ | test_main_racconta_i_passi verde |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
In ora_di_punta, >= al posto di > | A parità di passaggi vince l'ultima ora, non la prima: Largo Lista passa da 08 a 09 | test_stesso_output_sul_file_di_esempio |
| Il totale somma solo le entrate | Totale: 7 passaggi invece di 11. Con una stazione sola, 2 invece di 3 | test_stesso_output_sul_file_di_esempio, test_stesso_output_con_una_stazione_sola |
| Nomi giusti, ma tutto ancora in un blocco, senza funzioni | Il golden master è verde: stampa lo stesso. Ma il programma parte appena lo importi, e non c'è nessuna main | test_niente_codice_fuori_dalle_funzioni, test_main_racconta_i_passi |
La terza è la più comune: rinominare è facile e dà soddisfazione, e ci si ferma lì. Un programma con i nomi giusti e tutto in un blocco si legge meglio, ma non si può ancora provare un pezzo alla volta.
2 · Il registro delle pulizie
In italiano. Il programma c'è già in funzioni. Va cambiato un solo punto: l'except: con il pass.
- Voglio il numero di riga:
enumerate, che parte da 2 (la riga 1 è l'intestazione). - Le righe storte fanno sempre lo stesso errore,
ValueError:int("abc")e lo spacchettamento di una riga con un pezzo di meno o di più. - Nell'
except, al posto delpass, un avviso su stderr.
RIGA_DEL_PRIMO_DATO = 2 # la riga 1 è l'intestazione
def leggi_registro(percorso: str) -> list[tuple[str, int]]:
registro = []
with open(percorso, encoding="utf-8") as file:
righe = file.readlines()[1:]
for numero, riga in enumerate(righe, start=RIGA_DEL_PRIMO_DATO):
try:
treno, _pulitore, minuti = riga.strip().split(",")
registro.append((treno, int(minuti)))
except ValueError:
print(f"Riga {numero} ignorata: {riga.strip()}", file=sys.stderr)
return registroCosa vede chi lo lancia:
python palestra/pulizie_treni.py palestra/esempi/pulizie.csvRiga 5 ignorata: M14,Ernesto Pozzi,abc
Riga 6 ignorata: T28,Ivo Brambati
Riga 8 ignorata: M14,Tommaso Greco,25,extra
M12: 75 minuti
T28: 30 minuti
M16: 50 minuti
Totale: 155 minutiCon 2> /dev/null gli avvisi spariscono e restano le quattro righe di stdout, identiche a prima.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(f"Riga …") senza file=sys.stderr | L'avviso va su stdout: si mescola al resoconto, che non è più quello di prima | test_stesso_output_sul_file_di_esempio, test_le_righe_saltate_si_dicono_su_stderr |
except Exception: | Funziona, ma prende qualunque errore, anche un bug vero: l'errore tace | test_nessun_except_che_nasconde |
RIGA_DEL_PRIMO_DATO = 1 | Gli avvisi dicono «Riga 4» dove la riga è la 5: il numero è sfasato di uno | test_le_righe_saltate_si_dicono_su_stderr |
Lo spacchettamento treno, _pulitore, minuti = … fuori dal try | Una riga con due pezzi fa fermare il programma con un traceback: lo stdout non arriva mai | test_stesso_output_sul_file_di_esempio, test_le_righe_saltate_si_dicono_su_stderr |
L'ultima è il try troppo piccolo: protegge int(minuti) e dimentica che anche lo spacchettamento può fallire. Il try deve coprire tutte le righe che possono dare l'errore che aspetti.
3 · I turni dei capotreno
In italiano.
- I numeri: 60 sono i minuti di un'ora, 480 i minuti di un turno normale. Due costanti.
- I nomi:
mdiventaminuti_da_mezzanotte,tdiventaminuti,ndiventacapotreno. - Il bug: se il turno passa la mezzanotte,
fineè più piccola diinizioe il risultato è negativo. Non lo correggo: lo segnalo con# BUG:nella funzione dove si fa la sottrazione. - Ogni compito in una funzione: leggere un orario, contare i minuti, scrivere una riga.
MINUTI_PER_ORA = 60
MINUTI_DEL_TURNO = 480 # otto ore: oltre, è straordinario
def minuti_da_mezzanotte(orario: str) -> int:
ore, minuti = orario.split(":")
return int(ore) * MINUTI_PER_ORA + int(minuti)
def minuti_lavorati(inizio: str, fine: str) -> int:
# BUG: se il turno passa la mezzanotte (fine prima di inizio) il risultato è negativo.
# Non lo correggo: cambierebbe il resoconto già archiviato. Lo segnalo nella pull request.
return minuti_da_mezzanotte(fine) - minuti_da_mezzanotte(inizio)
def descrivi_turno(capotreno: str, minuti: int) -> str:
ore = minuti / MINUTI_PER_ORA
if minuti > MINUTI_DEL_TURNO:
straordinario = (minuti - MINUTI_DEL_TURNO) / MINUTI_PER_ORA
return f"{capotreno}: {ore:.2f} ore (straordinario {straordinario:.2f})"
return f"{capotreno}: {ore:.2f} ore"Il disegno.
La main legge il file e, per ogni riga, stampa descrivi_turno(capotreno, minuti_lavorati(inizio, fine)).
Passo per passo. Il turno di Nadia Russo, 22:00–06:00, come lo calcola il programma:
| Passo | Valore |
|---|---|
minuti_da_mezzanotte("06:00") | 6 * 60 + 0 = 360 |
minuti_da_mezzanotte("22:00") | 22 * 60 + 0 = 1320 |
minuti_lavorati("22:00", "06:00") | 360 − 1320 = −960 |
descrivi_turno(…) | −960 / 60 = −16: -16.00 ore |
È la riga che il golden master ha in fotografia. Rimane così, con il suo commento.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Il bug corretto: se i minuti sono negativi si aggiunge un giorno intero | Nadia Russo fa 8 ore, e va bene! Ma il resoconto è cambiato, e nessuno ha più il commento che avvisa | test_stesso_output_sul_file_di_esempio, test_il_bug_e_segnalato |
Il commento c'è, ma comincia con # Attenzione: | Per un lettore umano va bene. Per il test (e per chi cerca i bug con una ricerca) no: l'etichetta è # BUG: | test_il_bug_e_segnalato |
if minuti > 480: scritto con il numero, e la costante usata solo nell'altra riga | La costante c'è, ma in un punto il numero è rimasto sciolto: se il turno cambia, uno dei due si dimentica | test_niente_numeri_magici |
round(minuti / MINUTI_PER_ORA, 2) al posto di :.2f | 8.0 ore al posto di 8.00 ore, e il 2 di round è un numero senza nome | test_stesso_output_sul_file_di_esempio, test_stesso_output_senza_turni_di_notte, test_niente_numeri_magici |
La prima è il punto del capitolo. Il test rosso non vuol dire che hai sbagliato a correggere: vuol dire che hai fatto due mestieri insieme, e che il resoconto archiviato non è più quello che il programma stampa.
La storia
La storia è un programma solo, storia/biglietteria.py, e i livelli sono sei passaggi dallo stesso file. Qui trovi, per ogni livello, il ragionamento, il codice che cambia e le trappole. La soluzione completa è nello zip delle soluzioni.
Livello 1 · I nomi
In italiano. Ogni variabile vecchia ha un nome nuovo che dice cosa contiene. Si procede una alla volta, con F2, e dopo ognuna pytest.
| Prima | Dopo | Perché |
|---|---|---|
f, r | file, righe | il file e le sue righe |
st, gg, ta, za, et | per_stazione, per_giorno, per_tariffa, per_zone, per_eta | i conteggi |
tot, n, gr, sc | totale, biglietti, gratuiti, scartate | i contatori |
x, g, s, c, e, t, z, p | riga, giorno, stazione, tessera, eta, tariffa, zone, prezzo | i campi della riga e il prezzo |
mg, mi | giorno_migliore, incasso_migliore | il giorno migliore |
for riga in righe:
try:
giorno, stazione, tessera, eta, tariffa, zone = riga.strip().split(",")
giorno = int(giorno)
tessera = int(tessera)
eta = int(eta)
zone = int(zone)
if zone == 1:
prezzo = 2.2
elif zone == 2:
prezzo = 3.1
else:
prezzo = 4.0Il programma fa ancora la stessa cosa: pytest storia -k "resoconto or livello_1" è verde. Un ordine che aiuta: prima i nomi che capisci subito (riga, file), poi quelli che si capiscono guardando dove vengono usati (per_tariffa[tariffa][0] conta i biglietti, [1] l'incasso).
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Rinominare con «sostituisci tutto» e cambiare anche il testo: Per tariffe: al posto di Per tariffa: | Sembra la stessa cosa, ma è una riga di stdout diversa: il resoconto non è più quello di prima | test_resoconto_identico |
La rinomina con F2 cambia i nomi. La sostituzione di testo («sostituisci tutto») cambia anche le stringhe e i commenti, e lì dentro c'è l'uscita del programma.
Livello 2 · Le funzioni
In italiano.
- Il prezzo di un biglietto dipende da tariffa, età e zone: è
prezzo_biglietto, restituisce e non stampa. - La tessera speciale non entra in
prezzo_biglietto(la funzione non la conosce): la gestisceprezzo_pagato, che chiama quella. - La riga letta e registrata nei conteggi:
registra. Il ciclo con iltry:elabora. - Le stampe, divise per sezione:
stampa_i_conti,stampa_zone_ed_eta,stampa_la_coda. maine il bloccoif __name__ == "__main__":.
def prezzo_biglietto(tariffa: str, eta: int, zone: int) -> float:
prezzo = PREZZI_PER_ZONA.get(zone, PREZZO_DALLA_TERZA_ZONA)
prezzo = prezzo * COEFFICIENTI_TARIFFA[tariffa]
if eta > ETA_DEGLI_ANZIANI:
prezzo = prezzo * COEFFICIENTE_ANZIANI
if eta < ETA_SOTTO_LA_QUALE_E_GRATIS:
prezzo = 0
return round(prezzo, 2)
def main(argomenti: list[str]) -> int:
with open(argomenti[1], encoding="utf-8") as file:
righe = file.readlines()[1:]
resoconto = elabora(righe)
stampa_i_conti(resoconto)
stampa_zone_ed_eta(resoconto)
stampa_la_coda(resoconto)
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv))(Le costanti qui sono già quelle del livello 3: tu al livello 2 puoi avere ancora i numeri, 2.2 e 0.6.)
Il disegno.
Passo per passo. Il test prova prezzo_biglietto da solo, con tariffa, età e zone:
prezzo_biglietto(…) | Calcolo | Risultato |
|---|---|---|
("ordinario", 30, 2) | 3.1, senza sconti | 3.1 |
("studenti", 20, 1) | 2.2 × 0.6 | 1.32 |
("ordinario", 70, 1) | 2.2 × 0.5 | 1.1 |
("ordinario", 5, 3) | sotto i 6 anni: gratis | 0 |
("ordinario", 6, 1) | sei anni compiuti: paga | 2.2 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
In fondo, sys.exit(main(sys.argv)) senza il blocco if __name__ == "__main__": | Il resoconto esce lo stesso (il golden master è verde), ma importare il file lo fa partire: i test non riescono a provare le funzioni da sole | test_livello_2_il_programma_si_importa_senza_partire, test_livello_2_prezzo_biglietto, test_livello_2_il_calcolo_non_stampa, test_livello_2_ogni_funzione_fa_una_cosa, test_livello_5_chi_ha_65_anni_paga_ancora_intero |
eta <= ETA_SOTTO_LA_QUALE_E_GRATIS, al posto di < | Chi ha esattamente 6 anni non paga più: un confine spostato mentre si riscriveva | test_resoconto_identico, test_livello_2_prezzo_biglietto |
La seconda è il confine che si sposta senza che nessuno lo voglia. Il file prova1.csv ha apposta un biglietto di un bambino di 6 anni: è quello che lo ha preso.
Livello 3 · I numeri con un nome
In italiano. Ogni numero che conta passa in cima al file, con un nome che dice cosa è, non quanto vale.
# Tariffe: 1 zona 2.20, 2 zone 3.10, dalla terza 4.00. Studenti -40%, gruppi -20%.
PREZZI_PER_ZONA = {1: 2.2, 2: 3.1}
PREZZO_DALLA_TERZA_ZONA = 4.0
COEFFICIENTI_TARIFFA = {"ordinario": 1, "studenti": 0.6, "gruppo": 0.8}
COEFFICIENTE_ANZIANI = 0.5
ETA_DEGLI_ANZIANI = 65
ETA_SOTTO_LA_QUALE_E_GRATIS = 6
ETA_DEI_MAGGIORENNI = 18
RIGA_DEL_PRIMO_DATO = 2 # la riga 1 è l'intestazione
LUNGHEZZA_DEL_SEPARATORE = 35
ZONE_DEL_RESOCONTO = (1, 2, 3)Resta un numero: il 40417. Non ha un nome naturale: TESSERA_CHE_NON_PAGA è il nome che gli dà chi ha capito cosa fa, e solo allora. Prima di quel nome c'è la domanda: perché una sola tessera? Se un numero non si lascia chiamare, di solito vuol dire che nessuno sa perché sta lì. Lo rimandiamo al livello 5.
Le larghezze delle colonne (15 e 3) spariscono in una f-string: f" {nome:<15}{quanti:>3} …".
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Le costanti ci sono, ma if eta > 65: usa ancora il numero | Costante e numero dicono la stessa cosa adesso. Se la soglia cambia, ne cambia una sola | test_livello_3_niente_numeri_magici |
Livello 4 · Gli avvisi su stderr
In italiano. Dove c'era except: sc = sc + 1, ci vuole l'except stretto e l'avviso. Il conteggio resta: lo stdout stampa ancora «Righe scartate: 4».
def elabora(righe: list[str]) -> dict:
resoconto = nuovo_resoconto()
for numero, riga in enumerate(righe, start=RIGA_DEL_PRIMO_DATO):
try:
registra(resoconto, riga)
except ValueError:
print(f"Riga {numero} ignorata: {riga.strip()}", file=sys.stderr)
resoconto["scartate"] += 1
return resocontoCon ottobre.csv escono quattro avvisi, e tutti da ValueError: «n/d» al posto dell'età, la zona «tre», e due righe con troppi o troppo pochi pezzi.
python storia/biglietteria.py storia/dati/ottobre.csv > /dev/nullRiga 18 ignorata: 9,Largo Lista,40233,n/d,ordinario,2
Riga 34 ignorata: 14,Ponte Ciclo,40305
Riga 53 ignorata: 21,Via Variabile,40312,52,ordinario,tre
Riga 67 ignorata: 26,Piazza Query,40429,58,ordinario,2,extraLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
L'avviso con print(…) senza file=sys.stderr | Le quattro righe di avviso finiscono in cima allo stdout, prima del titolo | test_resoconto_identico, test_livello_4_le_righe_scartate_si_dicono_su_stderr |
except Exception: al posto di except ValueError: | I resoconti escono uguali, ma un bug vero finirebbe nello stesso avviso, travestito da riga storta | test_livello_4_nessun_except_che_nasconde |
Livello 5 · # BUG:
In italiano. Due cose non tornano, e vanno segnalate (non corrette).
- I 65 anni. Le regole di Aldo dicono «dai 65 anni compiuti si paga la metà». Il codice scrive
eta > 65: chi ha esattamente 65 anni paga intero. Il resoconto di ottobre ha una tessera di 65 anni, e il golden master ha il suo prezzo intero dentro. - La tessera che non paga. Un
ifche dà prezzo zero a una sola tessera, senza regole.
# BUG: la regola dice «dai 65 anni compiuti», ma con `>` chi ha esattamente
# 65 anni paga intero. Non lo correggo: il resoconto di Aldo è già archiviato.
if eta > ETA_DEGLI_ANZIANI:
prezzo = prezzo * COEFFICIENTE_ANZIANI# BUG: nessuna regola dice che questa tessera viaggia gratis, ma nel 2009 Aldo l'ha
# scritta qui e da allora fa pagare zero. Non la tocco (il resoconto cambierebbe):
# la porto al commissario Mapelli.
TESSERA_CHE_NON_PAGA = 40417Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
eta >= ETA_DEGLI_ANZIANI, e il commento del bug dei 65 tolto | Il bug è «corretto» (giusto!), ma il resoconto è cambiato: chi ha 65 anni adesso paga la metà. E dei due bug ne resta segnalato uno | test_resoconto_identico, test_livello_5_i_bug_sono_segnalati, test_livello_5_chi_ha_65_anni_paga_ancora_intero |
Tolto l'if della tessera speciale (e la costante con il suo commento) | Il resoconto di ottobre sale: la tessera adesso paga. Giusto o no, non lo decide chi rifattorizza | test_resoconto_identico, test_livello_5_i_bug_sono_segnalati |
Livello 6 · Ruff, e il finale
In italiano. Due comandi, che non devono più avere niente da dire.
ruff check storia/biglietteria.pyAll checks passed!ruff format storia/biglietteria.py1 file left unchangedSe non è così, ruff format sistema l'impaginazione da solo; per ruff check leggi il codice della regola. Le più comuni su questo programma: E722 (l'except da solo), UP031 (i % nelle stringhe), ANN001 e ANN201 (mancano i tipi).
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def fascia_di_eta(eta):, senza tipi | Funziona, ma Ruff chiede il tipo del parametro e quello del return: ANN001 e ANN201 | test_livello_6_ruff_check |
Il finale
Il numero sbucato al livello 3 è 40417. In dati/tessere.csv:
grep 40417 storia/dati/tessere.csv40417,Renato Bassipython storia/verifica.py "Renato Bassi"Il commissario Mapelli si toglie gli occhiali.
«Giusto. La tessera la fermiamo domattina, e la lettera ad Aldo la scrivo io.»Le piste sbagliate più probabili, e perché il commissario le scarta:
- La tessera dei 65 anni (Carla Bonomi): paga intero per il confine sbagliato. È il primo bug, non la porta sul retro.
- Il bambino con il biglietto a zero (Pietro Sala): sotto i 6 anni si viaggia gratis per regola. Uno zero giustificato non è un sospetto.
- Il numero con due cifre scambiate (40471, Davide Marchesi): una tessera vera, che paga regolarmente. Si copia il numero dal codice, non a memoria.
- Aldo Ronchi: ha scritto lui la porta sul retro, ma la sua tessera paga come tutte le altre.
Il filo della storia sta nell'ordine delle cose: il numero che non si lasciava nominare (livello 3) era un indizio, il commento # BUG: (livello 5) lo ha messo per iscritto, e il golden master ha impedito che il «sistemo io» lo facesse sparire senza dirlo a nessuno.