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.
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.
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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nomi più lunghi ma vuoti: dati, risultato, valore al posto di d, res, tmp | I nomi sono lunghi, ma non dicono niente di più. Il test ha una lista dei nomi vaghi più comuni | test_nessun_nome_vago |
Nel rinominare, ritocchi anche la scritta: f"{tessera}: € {saldi[tessera]:.2f}" al posto di euro | Il programma stampa una riga diversa: il comportamento è cambiato, anche se «sembra» uguale | test_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.
- 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. - Il programma ha tre compiti: leggere il file, stampare lo scontrino, e
mainche li mette in fila. Un compito, una funzione. - Chi stampa chiede i conti al modulo con
from calcolo_scontrino import ….
Il modulo nuovo:
def importo_riga(prezzo: float, quantita: int) -> float:
return prezzo * quantita
def totale_scontrino(importi: list[float]) -> float:
return sum(importi)E il programma:
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 dice | Vuol dire |
|---|---|
Non trovo calcolo_scontrino.py | Il file nuovo non c'è, o ha un altro nome |
In calcolo_scontrino.py ci sono 1 print | Il modulo che calcola stampa: non deve |
scontrino_distributore.py non importa calcolo_scontrino | I 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 sbagliato | Cosa succede | Il 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 troppo | test_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 import | Funziona, ma ora i conti sono in due posti: il file nuovo non serve a niente | test_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.
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.
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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Spostando il numero cambi ora < ORA_FINE_NOTTE in ora <= ORA_FINE_NOTTE | Il confine si sposta di un'ora: alle 5 la tariffa è quella di notte invece che l'ordinaria, e l'incasso scende | test_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 nome | test_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.
- L'
exceptda solo diventaexcept ValueError:: gli errori che ci aspettiamo da una riga rotta (int("molti"), o una riga con meno pezzi del previsto) sono tuttiValueError. - Dentro non c'è più
pass: c'è un avviso su stderr, con il numero della riga e il testo. - 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.
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.
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 file | Contenuto | Cosa succede |
|---|---|---|
| 2 | Porta Codice,120 | valida: 120 |
| 3 | Via Variabile,85 | valida: 205 |
| 4 | Largo Lista,molti | int("molti") alza ValueError: avviso Riga 4 ignorata: Largo Lista,molti |
| 5 | Ponte Ciclo | un pezzo solo: ValueError anche qui, avviso Riga 5 ignorata: Ponte Ciclo |
| 6 | Vecchia Fiera,12 | valida: 281 |
stdout resta Righe valide: 4 e Passeggeri contati: 281: gli avvisi viaggiano da un'altra parte.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
except Exception: con l'avviso dentro | Sembra a posto: l'avviso c'è. Ma Exception prende quasi tutti gli errori, anche i tuoi bug: un nome scritto male sparirebbe dietro un avviso | test_nessun_except_che_nasconde |
except ValueError: con continue al posto dell'avviso | Il tipo è giusto, ma il blocco tace: la riga rotta sparisce senza dirlo | test_nessun_except_che_nasconde, test_le_righe_rotte_si_dicono_su_stderr |
print(f"Riga … ignorata: …") senza file=sys.stderr | L'avviso finisce su stdout, in mezzo al risultato: l'uscita normale cambia | test_stesso_stdout_sul_file_di_esempio, test_le_righe_rotte_si_dicono_su_stderr |
5 · Il resoconto delle linee
In italiano.
- Il blocco che stampa il resoconto di una linea diventa una funzione,
stampa_resoconto(linea, passeggeri). - Le due liste (una per M, una per T) diventano un dizionario: la lettera della linea è la chiave, la lista dei passeggeri il valore.
- Il
forsulle chiavi chiama la funzione una volta per linea. - La riga di trattini ha un nome:
SEPARATORE.
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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Due funzioni, resoconto_m e resoconto_t, con lo stesso corpo | Hai messo i blocchi in due funzioni, ma sono sempre un copia e incolla: la ripetizione si è solo spostata | test_nessun_blocco_copiato_e_incollato |
Una funzione sola, ma i trattini sono scritti a mano due volte, nel main | Il resoconto è giusto, ma il testo "--------------------" compare ancora in due punti | test_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.
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 sbagliato | Cosa succede | Il 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 cima | Un commento sul cosa è rimasto | test_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.
ruff formatsistema le virgole, gli spazi e le righe con due istruzioni.ruff checksegnala il resto: dueimportnon usati (cancellati), il nomel(diventain_arrivo),== None(diventais None),== True(diventaif sciopero:).- I tipi a mano.
minuti_di_attesapuò restituire un numero o niente:int | None.
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 sbagliato | Cosa succede | Il 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 Ruff | test_ruff_format_non_cambierebbe_niente |
Il file è impaginato bene e ha i tipi, ma if minuti == None: è rimasto | Il formattatore non tocca i confronti: il linter segnala E711 | test_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.