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

Sette regole, 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: nei nomi, nelle costanti e nei commenti ci sono mille strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano quasi tutti i test e se ne fa scappare uno.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

pulito-sette-regole-soluzioni.zip31 KB

1 · La ricarica della tessera

In italiano. Per ogni nome chiedo: cosa c'è dentro? La riga del file è una riga, il primo pezzo è la tessera, il secondo l'importo; il dizionario che somma è saldi. calc diventa somma_ricariche_per_tessera: un verbo e cosa fa.

Python
import sys


def somma_ricariche_per_tessera(righe: list[str]) -> dict[str, float]:
    saldi = {}
    for riga in righe:
        tessera, importo = riga.strip().split(",")
        saldi[tessera] = saldi.get(tessera, 0) + float(importo)
    return saldi


def main(argomenti: list[str]) -> int:
    with open(argomenti[1], encoding="utf-8") as file:
        righe = file.readlines()[1:]
    saldi = somma_ricariche_per_tessera(righe)
    for tessera in saldi:
        print(f"{tessera}: {saldi[tessera]:.2f} euro")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Il nome della funzione e il nome del dizionario sono diversi: la funzione fa (verbo), il dizionario contiene (sostantivo).

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Nomi più lunghi ma vuoti: dati, risultato, valore al posto di d, res, tmpI nomi sono lunghi, ma non dicono niente di più. Il test ha una lista dei nomi vaghi più comunitest_nessun_nome_vago
Nel rinominare, ritocchi anche la scritta: f"{tessera}: € {saldi[tessera]:.2f}" al posto di euroIl programma stampa una riga diversa: il comportamento è cambiato, anche se «sembra» ugualetest_stesso_output_sul_file_di_esempio

La seconda è la più comune: mentre sistemi, ti viene voglia di «migliorare». Si migliora un passo alla volta, e mai insieme a una rinomina.


2 · Lo scontrino del distributore

In italiano.

  1. Il calcolo va in un file nuovo, calcolo_scontrino.py: una funzione per l'importo di una riga, una per il totale. Restituiscono, non stampano.
  2. Il programma ha tre compiti: leggere il file, stampare lo scontrino, e main che li mette in fila. Un compito, una funzione.
  3. Chi stampa chiede i conti al modulo con from calcolo_scontrino import ….

Il modulo nuovo:

Python
def importo_riga(prezzo: float, quantita: int) -> float:
    return prezzo * quantita


def totale_scontrino(importi: list[float]) -> float:
    return sum(importi)

E il programma:

Python
import sys

from calcolo_scontrino import importo_riga, totale_scontrino


def leggi_acquisti(percorso: str) -> list[tuple[str, float, int]]:
    with open(percorso, encoding="utf-8") as file:
        righe = file.readlines()[1:]
    acquisti = []
    for riga in righe:
        prodotto, prezzo, quantita = riga.strip().split(",")
        acquisti.append((prodotto, float(prezzo), int(quantita)))
    return acquisti


def stampa_scontrino(acquisti: list[tuple[str, float, int]]) -> None:
    importi = []
    for prodotto, prezzo, quantita in acquisti:
        importo = importo_riga(prezzo, quantita)
        importi.append(importo)
        print(f"{prodotto:<8} {quantita} x {prezzo:.2f} = {importo:.2f}")
    print(f"Totale: {totale_scontrino(importi):.2f}")


def main(argomenti: list[str]) -> int:
    stampa_scontrino(leggi_acquisti(argomenti[1]))
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Passo per passo. I messaggi del test di questo esercizio, e cosa vogliono dire:

Il test diceVuol dire
Non trovo calcolo_scontrino.pyIl file nuovo non c'è, o ha un altro nome
In calcolo_scontrino.py ci sono 1 printIl modulo che calcola stampa: non deve
scontrino_distributore.py non importa calcolo_scontrinoI conti li rifà il programma da sé
Funzioni con più di 8 righe (nome: righe)C'è ancora una funzione troppo lunga

Il lavoro, un passo alla volta: (1) crei calcolo_scontrino.py con le due funzioni; (2) in scontrino_distributore.py aggiungi l'import e usi importo_riga al posto di float(prezzo) * int(quantita); (3) sposti la lettura del file in leggi_acquisti; (4) lasci a stampa_scontrino solo la stampa. Dopo ogni passo, pytest.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
In calcolo_scontrino.py, importo_riga fa anche print(f"{prezzo:.2f} x {quantita} = ...")Il modulo calcola e stampa: lo scontrino ha righe di troppotest_stesso_output_sul_file_di_esempio, test_stesso_output_con_una_riga_sola, test_il_modulo_del_calcolo_non_stampa_e_non_legge_file
Il modulo esiste, ma il programma ha ricopiato le due funzioni dentro di sé e non fa nessun importFunziona, ma ora i conti sono in due posti: il file nuovo non serve a nientetest_il_programma_importa_il_modulo_del_calcolo

3 · Le fasce dei tornelli

In italiano. Ogni numero ha una domanda: cosa misura? Il 5 è l'ora in cui finisce la notte; il 23 quella in cui comincia; 7 e 10 sono l'inizio e la fine della punta del mattino, 17 e 20 quelli della sera; e poi i tre prezzi. Nove numeri, nove costanti, tutte in cima al file.

Python
import sys

ORA_FINE_NOTTE = 5
ORA_INIZIO_NOTTE = 23
ORA_INIZIO_PUNTA_MATTINA = 7
ORA_FINE_PUNTA_MATTINA = 10
ORA_INIZIO_PUNTA_SERA = 17
ORA_FINE_PUNTA_SERA = 20
TARIFFA_NOTTE = 1.5
TARIFFA_PUNTA = 2.4
TARIFFA_ORDINARIA = 2.0


def tariffa(ora: int) -> float:
    if ora < ORA_FINE_NOTTE or ora >= ORA_INIZIO_NOTTE:
        return TARIFFA_NOTTE
    if (
        ORA_INIZIO_PUNTA_MATTINA <= ora < ORA_FINE_PUNTA_MATTINA
        or ORA_INIZIO_PUNTA_SERA <= ora < ORA_FINE_PUNTA_SERA
    ):
        return TARIFFA_PUNTA
    return TARIFFA_ORDINARIA


def main(argomenti: list[str]) -> int:
    with open(argomenti[1], encoding="utf-8") as file:
        righe = file.readlines()[1:]
    for riga in righe:
        ora, passaggi = riga.strip().split(",")
        incasso = tariffa(int(ora)) * int(passaggi)
        print(f"{ora:>2}:00  {passaggi:>4} passaggi  {incasso:>8.2f} euro")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Il disegno.

inizio tariffa(ora) se ora è di notte sì: restituisci TARIFFA_NOTTE se ora è di punta sì: restituisci TARIFFA_PUNTA restituisci TARIFFA_ORDINARIAtariffa(ora)ora è di notterestituisci TARIFFA_NOTTEora è di puntarestituisci TARIFFA_PUNTArestituisciTARIFFA_ORDINARIAnosìnosì
Le tre tariffe

Il 0 e l'1 non sono magici (per il test, sono ammessi). Le costanti hanno un nome fatto di più parole con il trattino basso: ORA_FINE_NOTTE, non FINE.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Spostando il numero cambi ora < ORA_FINE_NOTTE in ora <= ORA_FINE_NOTTEIl confine si sposta di un'ora: alle 5 la tariffa è quella di notte invece che l'ordinaria, e l'incasso scendetest_stesso_output_sul_file_di_esempio
Il 23 ti sfugge: ora >= 23 resta scritto così com'èIl programma stampa le stesse cose, ma c'è ancora un numero senza nometest_niente_numeri_magici

La prima è la trappola classica delle costanti: il numero resta lo stesso, ma mentre lo sposti ti scappa un operatore. Per questo si rilancia pytest dopo ogni costante, non alla fine.


4 · I passeggeri della notte

In italiano.

  1. L'except da solo diventa except ValueError:: gli errori che ci aspettiamo da una riga rotta (int("molti"), o una riga con meno pezzi del previsto) sono tutti ValueError.
  2. Dentro non c'è più pass: c'è un avviso su stderr, con il numero della riga e il testo.
  3. La conversione della riga va in una funzione, passeggeri_della_riga: un compito, e se la riga è rotta la funzione si ferma con il suo errore.
Python
import sys


def passeggeri_della_riga(riga: str) -> int:
    stazione, passeggeri = riga.strip().split(",")
    return int(passeggeri)


def main(argomenti: list[str]) -> int:
    with open(argomenti[1], encoding="utf-8") as file:
        righe = file.readlines()[1:]
    righe_valide = 0
    totale = 0
    for numero_riga, riga in enumerate(righe, start=2):
        try:
            totale = totale + passeggeri_della_riga(riga)
            righe_valide = righe_valide + 1
        except ValueError:
            print(f"Riga {numero_riga} ignorata: {riga.strip()}", file=sys.stderr)
    print(f"Righe valide: {righe_valide}")
    print(f"Passeggeri contati: {totale}")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Il disegno.

inizio main(argomenti) righe_valide = 0, totale = 0 per ogni numero_riga, riga in righe se passeggeri_della_riga dà ValueError sì: mostra Riga ignorata (stderr) no: totale = totale + passeggeri righe_valide = righe_valide + 1 mostra Righe valide mostra Passeggeri contati restituisci 0main(argomenti)righe_valide = 0, totale = 0per ogni numero_riga, rigain righepasseggeri_della_rigadà ValueErrortotale = totale + passeggeririghe_valide = righe_valide+ 1mostra Riga ignorata(stderr)mostra Righe validemostra Passeggeri contatirestituisci 0nosìfiniti
Il ciclo che somma e avvisa

Passo per passo. Il numero della riga parte da 2 perché readlines()[1:] ha già scartato l'intestazione, che è la riga 1 del file: la prima riga di dati è la riga 2. enumerate(righe, start=2) conta proprio così.

Riga del fileContenutoCosa succede
2Porta Codice,120valida: 120
3Via Variabile,85valida: 205
4Largo Lista,moltiint("molti") alza ValueError: avviso Riga 4 ignorata: Largo Lista,molti
5Ponte Cicloun pezzo solo: ValueError anche qui, avviso Riga 5 ignorata: Ponte Ciclo
6Vecchia Fiera,12valida: 281

stdout resta Righe valide: 4 e Passeggeri contati: 281: gli avvisi viaggiano da un'altra parte.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
except Exception: con l'avviso dentroSembra a posto: l'avviso c'è. Ma Exception prende quasi tutti gli errori, anche i tuoi bug: un nome scritto male sparirebbe dietro un avvisotest_nessun_except_che_nasconde
except ValueError: con continue al posto dell'avvisoIl tipo è giusto, ma il blocco tace: la riga rotta sparisce senza dirlotest_nessun_except_che_nasconde, test_le_righe_rotte_si_dicono_su_stderr
print(f"Riga … ignorata: …") senza file=sys.stderrL'avviso finisce su stdout, in mezzo al risultato: l'uscita normale cambiatest_stesso_stdout_sul_file_di_esempio, test_le_righe_rotte_si_dicono_su_stderr

5 · Il resoconto delle linee

In italiano.

  1. Il blocco che stampa il resoconto di una linea diventa una funzione, stampa_resoconto(linea, passeggeri).
  2. Le due liste (una per M, una per T) diventano un dizionario: la lettera della linea è la chiave, la lista dei passeggeri il valore.
  3. Il for sulle chiavi chiama la funzione una volta per linea.
  4. La riga di trattini ha un nome: SEPARATORE.
Python
import sys

SEPARATORE = "--------------------"


def stampa_resoconto(linea: str, passeggeri: list[int]) -> None:
    print(f"Linea {linea}")
    print(f"  corse: {len(passeggeri)}")
    print(f"  passeggeri: {sum(passeggeri)}")
    print(f"  media: {sum(passeggeri) / len(passeggeri):.1f}")
    print(SEPARATORE)


def main(argomenti: list[str]) -> int:
    with open(argomenti[1], encoding="utf-8") as file:
        righe = file.readlines()[1:]
    per_linea = {"M": [], "T": []}
    for riga in righe:
        treno, passeggeri = riga.strip().split(",")
        per_linea[treno[0]].append(int(passeggeri))
    for linea in per_linea:
        stampa_resoconto(linea, per_linea[linea])
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Il dizionario tiene l'ordine di inserimento: prima M, poi T, come prima.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Due funzioni, resoconto_m e resoconto_t, con lo stesso corpoHai messo i blocchi in due funzioni, ma sono sempre un copia e incolla: la ripetizione si è solo spostatatest_nessun_blocco_copiato_e_incollato
Una funzione sola, ma i trattini sono scritti a mano due volte, nel mainIl resoconto è giusto, ma il testo "--------------------" compare ancora in due puntitest_nessun_testo_scritto_due_volte

La prima è la più sottile: «una funzione per ogni linea» non è «una funzione per tutte le linee». Se per aggiungere una linea devi scrivere una funzione nuova, la ripetizione c'è ancora.


6 · Il giro di ispezione

In italiano. I sei commenti dello scheletro ripetono la riga sotto: li tolgo tutti. Resta da spiegare l'unica riga che ha bisogno di un perché: perché i treni T contano doppio. Il commento lo dice, con la ragione.

Python
import sys

DOPPIO_CONTROLLO = 2


def main(argomenti: list[str]) -> int:
    with open(argomenti[1], encoding="utf-8") as file:
        righe = file.readlines()[1:]
    totale_minuti = 0
    for riga in righe:
        treno, minuti = riga.strip().split(",")
        minuti = int(minuti)
        # I treni T hanno due piani: il regolamento richiede un secondo ispettore,
        # quindi un secondo controllo, e i suoi minuti si contano doppi.
        if treno.startswith("T"):
            minuti = minuti * DOPPIO_CONTROLLO
        totale_minuti = totale_minuti + minuti
    print(f"Minuti di ispezione: {totale_minuti}")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Il commento sta sopra la riga strana, e dice una cosa che il codice non può dire: i treni T hanno due piani e il regolamento richiede un secondo controllo.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Il commento è «se il treno comincia per T raddoppio i minuti di ispezione»È un commento sul cosa riscritto con altre parole: dice quello che la riga sotto dice già, e non dice perchétest_resta_un_commento_che_dice_il_perche
Scrivi il commento sul perché, ma lasci # apro il file in cimaUn commento sul cosa è rimastotest_nessun_commento_sul_cosa

Il test non può capire un commento: cerca le parole del perché. Ma il criterio vale anche per te: se riscritto con altre parole dice la stessa cosa del codice, non è un commento utile.


7 · Gli orari del capolinea

In italiano.

  1. ruff format sistema le virgole, gli spazi e le righe con due istruzioni.
  2. ruff check segnala il resto: due import non usati (cancellati), il nome l (diventa in_arrivo), == None (diventa is None), == True (diventa if sciopero:).
  3. I tipi a mano. minuti_di_attesa può restituire un numero o niente: int | None.
Python
def minuti_di_attesa(orari: list[int], adesso: int) -> int | None:
    for orario in orari:
        if orario >= adesso:
            return orario - adesso
    return None


def treni_in_arrivo(orari: list[int], adesso: int, entro: int) -> list[int]:
    in_arrivo = []
    for orario in orari:
        if orario >= adesso and orario - adesso <= entro:
            in_arrivo.append(orario)
    return in_arrivo


def descrizione_attesa(minuti: int | None, sciopero: bool = False) -> str:
    if sciopero:
        return "sciopero in corso"
    if minuti is None:
        return "nessun treno"
    if minuti == 0:
        return "in arrivo"
    if minuti == 1:
        return "1 minuto"
    return f"{minuti} minuti"

Nota gli elif diventati if: dopo un return l'elif non serve, e ruff format non lo cambia da solo, ma un file con tanti return in fila si legge meglio così.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Tipi aggiunti e niente == None, ma le stringhe tra apici singoli: 'sciopero in corso'ruff check non ha niente da dire, ma ruff format le vorrebbe tra virgolette doppie: il file non è nella forma di Rufftest_ruff_format_non_cambierebbe_niente
Il file è impaginato bene e ha i tipi, ma if minuti == None: è rimastoIl formattatore non tocca i confronti: il linter segnala E711test_ruff_non_ha_niente_da_dire

Il comando che fa tornare tutto: ruff format palestra/orari_capolinea.py e poi ruff check palestra/orari_capolinea.py, finché non dicono niente.