Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test2. Rifattorizzare senza romperep. 59

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.

pulito-rifattorizzare-soluzioni.zip36 KB

La palestra

1 · I passaggi ai tornelli

In italiano. Il programma fa quattro cose, e ognuna diventa una funzione.

  1. Leggo il file e spezzo ogni riga.
  2. Conto, per ogni stazione, le entrate, le uscite e i passaggi di ogni ora.
  3. Dai passaggi di ogni ora ricavo l'ora di punta.
  4. Stampo una riga per stazione, e il totale.

La main è l'indice: legge, conta, stampa.

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

Il disegno.

inizio ora_di_punta(per_ora) punta = "", massimo = 0 per ogni ora, passaggi in per_ora se passaggi > massimo sì: massimo = passaggi punta = ora restituisci puntaora_di_punta(per_ora)punta = "", massimo = 0per ogni ora, passaggi inper_orapassaggi > massimomassimo = passaggipunta = orarestituisci puntanosìfiniti
L'ora di punta

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:

PassoCosa cambipytest
1I nomi, con F2 (d in stazioni, p in pezzi…)resta verde
2Il pezzo che stampa, in stampa_stazioneresta verde
3Il ciclo dell'ora di punta, in ora_di_puntaresta verde
4Il conteggio, in conta_per_stazioneresta verde
5La lettura, in leggi_passaggiresta verde
6Quello che resta diventa main, con il blocco if __name__test_main_racconta_i_passi verde

Le trappole.

Il codice sbagliatoCosa succedeIl 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 09test_stesso_output_sul_file_di_esempio
Il totale somma solo le entrateTotale: 7 passaggi invece di 11. Con una stazione sola, 2 invece di 3test_stesso_output_sul_file_di_esempio, test_stesso_output_con_una_stazione_sola
Nomi giusti, ma tutto ancora in un blocco, senza funzioniIl golden master è verde: stampa lo stesso. Ma il programma parte appena lo importi, e non c'è nessuna maintest_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.

  1. Voglio il numero di riga: enumerate, che parte da 2 (la riga 1 è l'intestazione).
  2. 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ù.
  3. Nell'except, al posto del pass, un avviso su stderr.
Python
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 registro

Cosa vede chi lo lancia:

Terminale
python palestra/pulizie_treni.py palestra/esempi/pulizie.csv
Riga 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 minuti

Con 2> /dev/null gli avvisi spariscono e restano le quattro righe di stdout, identiche a prima.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
print(f"Riga …") senza file=sys.stderrL'avviso va su stdout: si mescola al resoconto, che non è più quello di primatest_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 tacetest_nessun_except_che_nasconde
RIGA_DEL_PRIMO_DATO = 1Gli avvisi dicono «Riga 4» dove la riga è la 5: il numero è sfasato di unotest_le_righe_saltate_si_dicono_su_stderr
Lo spacchettamento treno, _pulitore, minuti = … fuori dal tryUna riga con due pezzi fa fermare il programma con un traceback: lo stdout non arriva maitest_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.

  1. I numeri: 60 sono i minuti di un'ora, 480 i minuti di un turno normale. Due costanti.
  2. I nomi: m diventa minuti_da_mezzanotte, t diventa minuti, n diventa capotreno.
  3. Il bug: se il turno passa la mezzanotte, fine è più piccola di inizio e il risultato è negativo. Non lo correggo: lo segnalo con # BUG: nella funzione dove si fa la sottrazione.
  4. Ogni compito in una funzione: leggere un orario, contare i minuti, scrivere una riga.
Python
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.

inizio descrivi_turno(capotreno, minuti) ore = minuti / MINUTI_PER_ORA se minuti > MINUTI_DEL_TURNO sì: straordinario = ore oltre il turno restituisci ore e straordinario restituisci oredescrivi_turno(capotreno,minuti)ore = minuti /MINUTI_PER_ORAminuti >MINUTI_DEL_TURNOstraordinario = ore oltre ilturnorestituisci ore estraordinariorestituisci orenosì
Il turno e lo straordinario

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:

PassoValore
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 sbagliatoCosa succedeIl test rosso
Il bug corretto: se i minuti sono negativi si aggiunge un giorno interoNadia Russo fa 8 ore, e va bene! Ma il resoconto è cambiato, e nessuno ha più il commento che avvisatest_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 rigaLa costante c'è, ma in un punto il numero è rimasto sciolto: se il turno cambia, uno dei due si dimenticatest_niente_numeri_magici
round(minuti / MINUTI_PER_ORA, 2) al posto di :.2f8.0 ore al posto di 8.00 ore, e il 2 di round è un numero senza nometest_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.

PrimaDopoPerché
f, rfile, righeil file e le sue righe
st, gg, ta, za, etper_stazione, per_giorno, per_tariffa, per_zone, per_etai conteggi
tot, n, gr, sctotale, biglietti, gratuiti, scartatei contatori
x, g, s, c, e, t, z, priga, giorno, stazione, tessera, eta, tariffa, zone, prezzoi campi della riga e il prezzo
mg, migiorno_migliore, incasso_miglioreil giorno migliore
Python
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.0

Il 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 sbagliatoCosa succedeIl 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 primatest_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.

  1. Il prezzo di un biglietto dipende da tariffa, età e zone: è prezzo_biglietto, restituisce e non stampa.
  2. La tessera speciale non entra in prezzo_biglietto (la funzione non la conosce): la gestisce prezzo_pagato, che chiama quella.
  3. La riga letta e registrata nei conteggi: registra. Il ciclo con il try: elabora.
  4. Le stampe, divise per sezione: stampa_i_conti, stampa_zone_ed_eta, stampa_la_coda.
  5. main e il blocco if __name__ == "__main__":.
Python
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.

inizio prezzo_biglietto(tariffa, eta, zone) prezzo = PREZZI_PER_ZONA.get(zone, ...) prezzo = prezzo * COEFFICIENTI_TARIFFA[tariffa] se eta > ETA_DEGLI_ANZIANI sì: prezzo = prezzo * COEFFICIENTE_ANZIANI se eta < ETA_SOTTO_LA_QUALE_E_GRATIS sì: prezzo = 0 restituisci round(prezzo, 2)prezzo_biglietto(tariffa,eta, zone)prezzo =PREZZI_PER_ZONA.get(zone,...)prezzo = prezzo *COEFFICIENTI_TARIFFA[tariffa]eta >ETA_DEGLI_ANZIANIprezzo = prezzo *COEFFICIENTE_ANZIANIeta <ETA_SOTTO_LA_QUALE_E_GRATISprezzo = 0restituisci round(prezzo, 2)nosìnosì
Il prezzo del biglietto

Passo per passo. Il test prova prezzo_biglietto da solo, con tariffa, età e zone:

prezzo_biglietto(…)CalcoloRisultato
("ordinario", 30, 2)3.1, senza sconti3.1
("studenti", 20, 1)2.2 × 0.61.32
("ordinario", 70, 1)2.2 × 0.51.1
("ordinario", 5, 3)sotto i 6 anni: gratis0
("ordinario", 6, 1)sei anni compiuti: paga2.2

Le trappole.

Il codice sbagliatoCosa succedeIl 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 soletest_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 riscrivevatest_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.

Python
# 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 sbagliatoCosa succedeIl test rosso
Le costanti ci sono, ma if eta > 65: usa ancora il numeroCostante e numero dicono la stessa cosa adesso. Se la soglia cambia, ne cambia una solatest_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».

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

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

Terminale
python storia/biglietteria.py storia/dati/ottobre.csv > /dev/null
Riga 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,extra

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
L'avviso con print(…) senza file=sys.stderrLe quattro righe di avviso finiscono in cima allo stdout, prima del titolotest_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 stortatest_livello_4_nessun_except_che_nasconde

Livello 5 · # BUG:

In italiano. Due cose non tornano, e vanno segnalate (non corrette).

  1. 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.
  2. La tessera che non paga. Un if che dà prezzo zero a una sola tessera, senza regole.
Python
    # 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
Python
# 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 = 40417

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
eta >= ETA_DEGLI_ANZIANI, e il commento del bug dei 65 toltoIl bug è «corretto» (giusto!), ma il resoconto è cambiato: chi ha 65 anni adesso paga la metà. E dei due bug ne resta segnalato unotest_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 rifattorizzatest_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.

Terminale
ruff check storia/biglietteria.py
All checks passed!
Terminale
ruff format storia/biglietteria.py
1 file left unchanged

Se 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 sbagliatoCosa succedeIl test rosso
def fascia_di_eta(eta):, senza tipiFunziona, ma Ruff chiede il tipo del parametro e quello del return: ANN001 e ANN201test_livello_6_ruff_check

Il finale

Il numero sbucato al livello 3 è 40417. In dati/tessere.csv:

Terminale
grep 40417 storia/dati/tessere.csv
40417,Renato Bassi
Terminale
python 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.