Le stringhe, 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: con le stringhe le strade giuste sono quasi sempre più di una. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano qualche test e si rompono su un altro.
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 · Il comando del tornello
In italiano. Tolgo gli spazi ai lati, poi abbasso tutto. Restituisco il risultato.
def comando(testo: str) -> str:
return testo.strip().lower()strip() toglie anche l'«a capo»: per lui spazi, tabulazioni e «a capo» sono tutti spazi bianchi. Va bene anche l'ordine opposto, testo.lower().strip().
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
testo.strip() su una riga, poi return testo.lower() | La stringa senza spazi va persa: il comando esce minuscolo, ma con gli spazi ai lati ancora lì | test_toglie_gli_spazi_e_abbassa, test_anche_l_a_capo_si_toglie, test_gli_spazi_in_mezzo_restano |
return testo.replace(" ", "").lower() | Toglie anche gli spazi in mezzo ("apritutto"). E l'«a capo» non è uno spazio: resta lì | test_anche_l_a_capo_si_toglie, test_gli_spazi_in_mezzo_restano |
La prima è la trappola del capitolo: una stringa non cambia mai, i metodi ne danno una nuova.
2 · Il file del registro
In italiano. Abbasso tutto il nome, poi chiedo se finisce con .csv. La risposta di endswith è già True o False: la restituisco così com'è.
def e_un_registro(nome_file: str) -> bool:
return nome_file.lower().endswith(".csv")Niente if: quando un metodo risponde già True o False, basta restituire la sua risposta.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return ".csv" in nome_file.lower() | in cerca dappertutto: turni.csv.bak contiene .csv, e diventa un registro | test_la_copia_non_e_un_registro |
return nome_file.endswith(".csv") | TURNI_DICEMBRE.CSV finisce con .CSV, maiuscolo: per Python è un'altra cosa | test_le_maiuscole_non_contano |
3 · La nota per il tecnico
In italiano. Scrivo l'etichetta, un uguale, e il valore con !r: Python lo scrive come lo scriveresti tu nel codice.
def nota(etichetta: str, valore: str | int) -> str:
return f"{etichetta} = {valore!r}"Con !r un testo esce tra virgolette, con gli spazi in vista e l'«a capo» scritto come \n; un numero esce senza virgolette. Le virgolette le decide Python, guardando il tipo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
f"{etichetta} = {valore}" | Niente virgolette: treno = M12. E gli spazi ai lati non si vedono più | test_il_testo_ha_le_virgolette, test_gli_spazi_si_vedono, test_anche_l_a_capo_si_vede |
f"{etichetta} = '{valore}'", le virgolette a mano | Il numero 2 diventa '2', come se fosse testo. E l'«a capo» va a capo davvero, invece di vedersi | test_un_numero_non_ha_virgolette, test_anche_l_a_capo_si_vede |
4 · La tessera coperta
In italiano.
- Gli asterischi sono tanti quante le cifre, meno le quattro che si vedono.
- Le cifre che si vedono sono le ultime quattro: una fetta dalla fine.
- Attacco i due pezzi.
def tessera_coperta(numero: str) -> str:
asterischi = "*" * (len(numero) - 4)
return asterischi + numero[-4:]Con "4417203398": dieci cifre, quindi sei asterischi; numero[-4:] è "3398". Con "2026": zero asterischi, e "*" * 0 è la stringa vuota.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
numero[:4] al posto di numero[-4:] | Si vedono le prime quattro: "******4417" | test_si_vedono_solo_le_ultime_quattro, test_una_tessera_piu_corta |
numero[-4], senza i due punti | Una casella sola, la quartultima: "******3" | test_si_vedono_solo_le_ultime_quattro, test_la_lunghezza_resta_la_stessa, test_una_tessera_piu_corta, test_quattro_cifre_soltanto |
"*" * len(numero) + numero[-4:] | Un asterisco per ogni cifra, più le quattro cifre: "**********3398", troppo lunga | test_si_vedono_solo_le_ultime_quattro, test_la_lunghezza_resta_la_stessa, test_una_tessera_piu_corta, test_quattro_cifre_soltanto |
[-4] e [-4:] sono a due caratteri di distanza: il primo è una casella, il secondo è una fetta.
5 · Lo spazio di troppo
In italiano.
- Taglio il testo nelle sue parole con
split(), senza niente tra le parentesi: i gruppi di spazi spariscono, anche quelli ai lati. - Riattacco le parole con uno spazio solo.
def spazi_giusti(testo: str) -> str:
parole = testo.split()
return " ".join(parole)Passo per passo, con il secondo esempio:
testo = " Treno M12 in arrivo "
parole = testo.split() # ['Treno', 'M12', 'in', 'arrivo']: niente pezzi vuoti, niente spazi
" ".join(parole) # 'Treno M12 in arrivo'Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return testo.strip() | Toglie solo gli spazi ai lati: in mezzo restano tutti | test_due_spazi_in_mezzo, test_tanti_spazi_in_mezzo, test_spazi_anche_ai_lati |
replace di due spazi con uno, poi strip() | Ogni coppia di spazi diventa uno spazio. Con due spazi funziona; con cinque ne restano tre, perché replace passa una volta sola | test_tanti_spazi_in_mezzo, test_spazi_anche_ai_lati |
return " ".join(testo.split(" ")) | split(" ") lascia i pezzi vuoti, e join rimette uno spazio per ognuno: torna il testo di partenza, identico | test_due_spazi_in_mezzo, test_tanti_spazi_in_mezzo, test_spazi_anche_ai_lati |
La seconda è la più insidiosa: sul primo esempio che provi a mano, con due spazi, funziona.
6 · Il cartellino
In italiano.
- Taglio la voce sulla virgola: prima il cognome, poi il nome.
- Pulisco ogni pezzo per conto suo: via gli spazi ai lati, la maiuscola a ogni parola.
- Li rimetto insieme al contrario: prima il nome, poi il cognome.
def cartellino(voce: str) -> str:
pezzi = voce.split(",")
cognome = pezzi[0].strip().title()
nome = pezzi[1].strip().title()
return f"{nome} {cognome}"Passo per passo, con il secondo esempio:
voce = " colombo , SERGIO "
pezzi = voce.split(",") # [' colombo ', ' SERGIO ']: gli spazi restano attaccati ai pezzi
cognome = pezzi[0].strip().title() # 'Colombo'
nome = pezzi[1].strip().title() # 'Sergio'
f"{nome} {cognome}" # 'Sergio Colombo'Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessuno strip sui pezzi | Lo spazio dopo la virgola resta attaccato al nome: " Nadia Russo" | test_prima_il_nome_poi_il_cognome, test_spazi_dappertutto, test_due_nomi |
voce.split(", "), con lo spazio, e niente strip | Funziona finché dopo la virgola c'è esattamente uno spazio. Con gli spazi a caso del secondo test, nome e cognome si tengono i loro: il cartellino ha spazi davanti e in mezzo | test_spazi_dappertutto |
capitalize() al posto di title() | La maiuscola va solo alla prima parola: "Lucia maria Ferri" | test_due_nomi |
7 · Il tabellone delle partenze
In italiano. Una f-string sola: l'ora, due spazi, la stazione in 14 caselle a sinistra, i minuti in 3 caselle a destra, poi min.
def riga_tabellone(ora: str, stazione: str, minuti: int) -> str:
return f"{ora} {stazione:<14}{minuti:>3} min"Porta Codice ha 12 lettere: :<14 aggiunge due spazi dietro. 3 è una cifra: :>3 aggiunge due spazi davanti. Per i numeri, a destra è già l'allineamento normale, quindi anche {minuti:3} funziona; scrivere > rende chiaro cosa vuoi.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
{stazione:>14} | La stazione si allinea a destra: gli spazi in più finiscono davanti al nome, invece che dietro | test_una_riga, test_un_altra_riga |
Nessuna larghezza: solo {stazione} e {minuti} | Ogni riga è lunga quanto le sue parole: le colonne non stanno in colonna | test_una_riga, test_un_altra_riga, test_le_righe_sono_lunghe_uguali |
8 · Il ritardo nell'avviso
In italiano.
- Abbasso tutto l'avviso, così le maiuscole non contano più.
- Cerco dove comincia
"ritardo di "; il numero comincia subito dopo, cioè tante caselle più avanti quanto è lungo"ritardo di ". - Cerco dove comincia
" minuti": lì finisce il numero. - Prendo la fetta in mezzo e la trasformo in intero.
def minuti_di_ritardo(avviso: str) -> int:
testo = avviso.lower()
inizio = testo.find("ritardo di ") + len("ritardo di ")
fine = testo.find(" minuti")
return int(testo[inizio:fine])Passo per passo, con i due avvisi dei test:
"treno m12: ritardo di 12 minuti." | "guasto a ponte ciclo, treno m16: ritardo di 125 minuti. ci scusiamo." | |
|---|---|---|
testo.find("ritardo di ") | 11 | 33 |
len("ritardo di ") | 11 | 11 |
inizio | 22 | 44 |
fine | 24 | 47 |
testo[inizio:fine] | '12' | '125' |
int(...) | 12 | 125 |
La fetta si adatta da sola alla lunghezza del numero, perché la fine non è fissa: è dove comincia " minuti".
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessun lower() | Nell'avviso maiuscolo find non trova niente e dà -1. La fetta prende un pezzo a caso, e int() si ferma: ValueError: invalid literal for int() with base 10: ' RITARDO DI 5 MINUTI' | test_anche_tutto_maiuscolo |
Due caselle fisse: testo[inizio:inizio + 2] | Con 12 funziona, con 5 anche (int("5 ") perdona lo spazio). Con 125 dà 12 | test_il_numero_puo_essere_lungo |
Senza + len("ritardo di ") | La fetta comincia da «ritardo»: ValueError: invalid literal for int() with base 10: 'ritardo di 12' | test_il_numero_dei_minuti, test_anche_tutto_maiuscolo, test_il_numero_puo_essere_lungo |
La prima è la trappola di find della teoria: -1 non è un errore, è un numero, e il programma va avanti con quello.
La storia
Livello 1 · Il nome della stazione
In italiano. Tolgo gli spazi ai lati, cambio il trattino basso in spazio, metto la maiuscola a ogni parola.
def pulisci_stazione(grezza: str) -> str:
return grezza.strip().replace("_", " ").title()Nel quaderno: la stazione della prima riga è 'Porta Codice'.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
capitalize() al posto di title() | "Porta codice". E con il livello 1 cadono anche il 2 e il 4, che lo usano | i tre test del livello 1, i due del livello 2, i due del livello 4 |
I tre metodi su tre righe, senza = | Resta solo la risposta di title() sul nome sporco: Porta_Codice, con il trattino e gli spazi ai lati. "Ponte Ciclo", già pulito, passa lo stesso | test_livello_1_spazi_trattino_e_maiuscole, test_livello_1_tutto_maiuscolo, i due del livello 2, i due del livello 4 |
Un errore in una funzione si porta dietro tutte quelle che la usano. Se il livello 4 è rosso senza motivo, controlla prima l'1.
Livello 2 · L'annuncio
In italiano. La frase con tre buchi: l'ora così com'è, il treno in maiuscolo, la stazione pulita dal livello 1.
def annuncio(ora: str, treno: str, stazione: str) -> str:
return f"Ore {ora}. Il treno {treno.upper()} per {pulisci_stazione(stazione)} è in arrivo."Nel quaderno: Ore 06:00. Il treno M12 per Porta Codice è in arrivo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
La f dimenticata | La voce legge le graffe: "Ore {ora}. Il treno {treno.upper()} per …" | i due test del livello 2, i due del livello 4 |
{treno} senza upper() | "Il treno m12". Il test con "M18", già maiuscolo, passa | test_livello_2_l_annuncio, test_livello_4_una_riga |
Livello 3 · Il prezzo
In italiano.
- La virgola diventa punto, perché
floatvuole il punto. - Il testo diventa un numero.
- Il numero diventa testo con due decimali.
- Il punto torna virgola, e attacco
" euro".
def prezzo_in_euro(testo: str) -> str:
numero = float(testo.replace(",", "."))
con_il_punto = f"{numero:.2f}"
return con_il_punto.replace(".", ",") + " euro"Passo per passo, con " 3,1 ":
| Riga | Risultato |
|---|---|
testo.replace(",", ".") | " 3.1 " |
float(...) | 3.1: gli spazi ai lati non danno fastidio a float |
f"{numero:.2f}" | "3.10" |
con_il_punto.replace(".", ",") + " euro" | "3,10 euro" |
Nel quaderno: il biglietto per Piazza Query costa 3,10 euro.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
float(testo), senza il primo replace | ValueError: could not convert string to float: '2,2'. Il prezzo tondo "2" passa, perché non ha la virgola | test_livello_3_due_decimali_con_la_virgola, test_livello_3_con_gli_spazi, i due del livello 4 |
round(numero, 2) e str() al posto di :.2f | "2,2 euro" e "2,0 euro": lo zero in fondo non c'è | i tre test del livello 3, i due del livello 4 |
| Il punto non torna virgola | "2.20 euro" | i tre test del livello 3, i due del livello 4 |
round cambia il numero; :.2f cambia come lo scrivi. Per uno scontrino serve il secondo.
Livello 4 · La riga della bobina
In italiano. Taglio la riga sulla sbarretta: quattro pezzi. I primi tre vanno al livello 2, il quarto al livello 3. Attacco le due frasi.
def componi(riga: str) -> str:
pezzi = riga.split("|")
frase = annuncio(pezzi[0], pezzi[1], pezzi[2])
prezzo = prezzo_in_euro(pezzi[3])
return f"{frase} Biglietto: {prezzo}."Nel quaderno, alle 06:25: Ore 06:25. Il treno M12 per Largo Lista è in arrivo. Biglietto: 2,50 euro.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
riga.split(",") | Una virgola c'è solo dentro il prezzo: i pezzi sono due, e pezzi[2] dà IndexError: list index out of range | test_livello_4_una_riga, test_livello_4_un_altra_riga |
I pezzi contati da 1, fino a pezzi[4] | I pezzi sono quattro, numerati da 0 a 3: IndexError: list index out of range | test_livello_4_una_riga, test_livello_4_un_altra_riga |
Livello 5 · Le righe che non sono annunci
In italiano.
- Prendo l'ultimo pezzo della riga.
- Tolgo gli spazi ai lati e la virgola dei decimali.
- Chiedo se quello che resta è fatto solo di cifre.
def e_un_annuncio(riga: str) -> bool:
prezzo = riga.split("|")[-1]
return prezzo.strip().replace(",", "").isdigit()Passo per passo, con tre ultimi pezzi:
ultimo pezzo strip() replace(",", "") isdigit()
" 3,1 " "3,1" "31" True
" occaP" "occaP" "occaP" False
" 02:70" "02:70" "02:70" False: i due punti non sono una cifraNel quaderno: le righe che non sono annunci sono 8. Il vecchio programma provava a fare float anche del loro ultimo pezzo: per questo si è fermato.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return riga[-1].isdigit() | Guarda l'ultimo carattere, non l'ultimo pezzo: " 3,1 " finisce con uno spazio (falso), "03:80" finisce con uno zero (vero) | test_livello_5_un_prezzo_con_gli_spazi, test_livello_5_un_ora_non_e_un_prezzo |
Senza replace(",", "") | "2,2".isdigit() è False: ogni prezzo con i decimali sembra truccato | test_livello_5_un_prezzo_con_la_virgola, test_livello_5_un_prezzo_con_gli_spazi |
Senza strip() | In " 31 " ci sono due spazi, e gli spazi non sono cifre | test_livello_5_un_prezzo_con_gli_spazi |
Livello 6 · La parola al contrario
In italiano. Prendo l'ultimo pezzo, tolgo gli spazi ai lati, lo leggo da destra a sinistra, lo abbasso.
def parola_nascosta(riga: str) -> str:
ultimo = riga.split("|")[-1]
return ultimo.strip()[::-1].lower()Nel quaderno, le otto righe truccate, nell'ordine della bobina:
ora ultimo pezzo parola
06:12 " occaP" pacco
06:31 "LUS " sul
06:44 "onert" treno
06:58 "ellED " delle
07:05 " 02:70" 07:20
07:14 "rep" per
07:20 " OGRAL" largo
07:31 "atsil" listaIl messaggio: pacco sul treno delle 07:20 per largo lista.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
[:-1] al posto di [::-1] | Toglie l'ultima lettera invece di girare: "allet" | i quattro test del livello 6 |
| La fetta al contrario su tutta la riga | Gira anche ora, treno e stazione: la parola c'è, ma seguita dal resto della riga al contrario | i quattro test del livello 6 |
Senza strip() | Gli spazi ai lati girano con la parola, e restano attaccati | test_livello_6_senza_spazi_ai_lati |
Il finale
- Livello 6: il messaggio dice pacco sul treno delle 07:20 per largo lista.
- Livello 5: tra gli annunci veri, alle 07:20 ce ne sono due. Il M16 va a Piazza Query; il M14 va a Largo Lista.
- Alle 07:20 c'è anche una terza riga, il M21 per Largo Lista. Ma al posto del prezzo ha
OGRAL: è una riga truccata, il pezzolargodel messaggio. Non è un treno vero. - E il M18 delle 07:02 va sì a Largo Lista, ma all'ora sbagliata.
Il treno da fermare è il M14.
python storia/verifica.py "M14"