Etichette e scatole, le soluzioni
Il disegno, il ragionamento, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il disegno o il codice → passo per passo → le trappole.
Nei disegni da prevedere, la risposta conta meno del disegno. Se hai la risposta giusta ma il disegno era diverso, rifallo: la prossima volta il caso fortunato non torna.
Nelle funzioni da correggere, la tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. 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 cartello delle fermate
In italiano. cartello = fermate non copia: attacca una seconda etichetta alla stessa lista. L'append lo fa la lista, e le etichette sono due.
Il disegno, alla fine:
- 1A ·
["Porta Codice", "Via Variabile", "Largo Lista"] - 1B ·
1
Passo per passo.
- Riga 1: una scatola, un'etichetta.
- Riga 2: nessuna scatola nuova.
cartellosi attacca alla scatola difermate. - Riga 3: la scatola riceve
"Largo Lista". È l'unica.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
1A ["Porta Codice", "Via Variabile"] | Hai letto cartello = fermate come una copia. Il bug di tutto il capitolo | test_disegno_1_fermate |
1B 2 | Hai contato le etichette, non le scatole | test_disegno_1_quante_liste |
2 · L'etichetta che si sposta
In italiano. Alla riga 2, riserva si attacca alla scatola di treno. Alla riga 3, treno si stacca e va su una scatola nuova; riserva resta dov'era. Da lì in poi, quello che fai con treno non arriva a riserva.
Passo per passo.
- 2A ·
["motrice", "carrozza"] - 2B ·
2
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
2A ["motrice", "bici", "motrice"] | Hai pensato che riserva segua treno. Ma un'etichetta non segue un'altra etichetta: è attaccata a una scatola | test_disegno_2_riserva |
2A ["motrice", "carrozza", "motrice"] | Hai fatto lavorare l'append sulla scatola vecchia. Alla riga 4, però, treno è già sulla scatola nuova | test_disegno_2_riserva |
2B 1 | Hai pensato che = cambi il contenuto della scatola. = prepara una scatola nuova e ci sposta l'etichetta | test_disegno_2_quante_liste |
3 · Il numero, la stringa, la lista
In italiano. Tre storie con lo stesso inizio, una seconda etichetta sulla stessa scatola. Poi decide il tipo.
liberi -= 3vuol direliberi = liberi - 3: una scatola nuova, il 5, e l'etichettaliberici va sopra. Il numero 8 non si tocca.replacenon cambia la stringa: ne restituisce una nuova, e=ci spostadisplay.removecambia la lista. E la lista è una sola.
Il disegno, alla fine:
- 3A ·
8 - 3B ·
"treno in arrivo" - 3C ·
["A", "C"]
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
3A 5 | Hai trattato il numero come una lista. Un int non si cambia: -= fa una scatola nuova | test_disegno_3_posti |
3B "treno in partenza" | Hai pensato che replace cambi la stringa. Le stringhe non si cambiano mai: replace, upper, strip ne fanno una nuova | test_disegno_3_annuncio |
3C ["A", "B", "C"] | Hai trattato la lista come il numero. remove cambia la scatola, e panchine è attaccata lì | test_disegno_3_panchine |
4 · Uguali o la stessa?
In italiano. Dopo le quattro righe ci sono tre scatole: quella di mattina e notte, quella di sera, quella di festivo. Hanno tutte lo stesso contenuto. == guarda il contenuto; is chiede se la scatola è una sola.
Passo per passo.
- 4A ·
True: stesso contenuto. - 4B ·
False: due scatole. - 4C ·
True: una scatola, due etichette. - 4D ·
True: l'appendha cambiato la scatola dimattinaenotte.festivoè una copia fatta prima, eseranon c'entra.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
4A False | Hai pensato che == chieda «la stessa lista?». Chiede «lo stesso contenuto?» | test_disegno_4_uguali |
4B True | Hai usato is come ==. Due liste scritte uguali sono due scatole | test_disegno_4_la_stessa_mattina_e_sera |
4C False | Hai letto notte = mattina come una copia | test_disegno_4_la_stessa_notte_e_mattina |
4D False | Hai fatto arrivare Vecchia Fiera anche a festivo. Ma list(mattina) ha preparato una scatola nuova, e da lì in poi è per conto suo | test_disegno_4_dopo_l_append |
5 · La copia a metà
In italiano. Dentro binari ci sono due frecce. list(binari) prepara una scatola esterna nuova e ci copia le frecce: i due binari restano in comune. domani[0].append(...) segue una freccia in comune, e cambia un binario di tutti e due. domani.append(...) cambia solo la scatola esterna di domani.
Il disegno, alla fine:
- 5A ·
[["M12", "M14", "M18"], ["M16"]] - 5B ·
True - 5C ·
5: le due esterne, i due binari in comune, il binario del M20.
Passo per passo.
- Riga 1: tre scatole. L'esterna di
binarie i due binari. - Riga 2: una scatola in più, l'esterna di
domani, con due frecce copiate. Quattro scatole. - Riga 3:
domani[0]è il binario del M12, quello di tutti e due. Riceve il M18. - Riga 4: una scatola nuova,
["M20"], e una freccia in più nell'esterna didomani. Cinque scatole.
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
5A [["M12", "M14"], ["M16"]] | Hai pensato che list() copi tutto, anche dentro. Copia un piano solo | test_disegno_5_binari |
5A [["M12", "M14", "M18"], ["M16"], ["M20"]] | Hai trattato domani come un'altra etichetta su binari. La scatola esterna, invece, è nuova | test_disegno_5_binari |
5B False | Le esterne sono due, ma le frecce dentro portano allo stesso binario | test_disegno_5_lo_stesso_binario |
5C 7 | Hai contato i binari due volte, una per ogni lista esterna. Conta le scatole, non le frecce | test_disegno_5_quante_liste |
6 · La lista entra nella funzione
In italiano.
- La chiamata attacca
vagonialla scatola ditreno. vagoni.append("bici")cambia quella scatola: fuori,trenoha la bici.vagoni = ["motrice"]sposta l'etichetta della funzione su una scatola nuova.trenoresta dov'era.vagoni.append("carrozza")lavora sulla scatola nuova.len(vagoni)conta la scatola nuova: 2.
Passo per passo.
dentro prepara, dopo vagoni.append("bici")
┌─ fuori ────────┐
│ treno ────────┼──┐
└────────────────┘ │
├──▶ list [ "motrice", "carrozza", "motrice", "bici" ]
┌─ prepara ──────┐ │
│ vagoni ────────┼──┘
└────────────────┘
dentro prepara, dopo vagoni = ["motrice"] e vagoni.append("carrozza")
┌─ fuori ────────┐
│ treno ────────┼─────▶ list [ "motrice", "carrozza", "motrice", "bici" ]
└────────────────┘
┌─ prepara ──────┐
│ vagoni ────────┼─────▶ list [ "motrice", "carrozza" ]
└────────────────┘Al return il riquadro di prepara si butta. La scatola nuova non ha più etichette, e Python butta anche lei: è servita solo per contare.
- 6A ·
["motrice", "carrozza", "motrice", "bici"] - 6B ·
2
Le trappole.
| La risposta sbagliata | Cosa succede | Il test rosso |
|---|---|---|
6A ["motrice", "carrozza", "motrice"] | Hai pensato che la funzione riceva una copia. Riceve un'etichetta sulla stessa scatola | test_disegno_6_treno |
6A ["motrice", "carrozza"] | Hai pensato che vagoni = … cambi anche treno. Dentro la funzione = sposta solo l'etichetta della funzione | test_disegno_6_treno |
6B 4 | Hai contato i vagoni di treno. Ma al return, vagoni è già sulla scatola nuova | test_disegno_6_quanti |
7 · La deviazione
In italiano.
- Prima di tutto, una scatola nuova con lo stesso contenuto del percorso.
- Tolgo la fermata dalla scatola nuova.
- Restituisco la scatola nuova.
def senza_fermata(percorso: list[str], fermata: str) -> list[str]:
domenica = list(percorso)
domenica.remove(fermata)
return domenicaPasso per passo. Con il codice di partenza, domenica = percorso è una seconda etichetta sulla scatola che arriva da fuori. Con list(percorso):
dentro senza_fermata, dopo domenica.remove(fermata)
┌ fuori ─────────┐
│ feriale ──────┼──┐
└────────────────┘ │
├──▶ list [ "Porta Codice", "Via Variabile", "Largo Lista" ]
┌ senza_fermata ─┐ │
│ percorso ──────┼──┘
│ domenica ──────┼─────▶ list [ "Porta Codice", "Largo Lista" ]
└────────────────┘Va bene anche domenica = percorso[:] o percorso.copy(). Oppure un ciclo che costruisce la lista nuova con tutte le fermate tranne quella: anche così la scatola di fuori non si tocca.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
domenica = percorso (il codice di partenza) | Due etichette, una scatola: il remove arriva al feriale | test_il_percorso_feriale_non_cambia, test_e_una_lista_nuova |
percorso.remove(fermata), poi return list(percorso) | La copia c'è, ma arriva tardi: il remove ha già cambiato il feriale | test_il_percorso_feriale_non_cambia |
domenica = list(percorso).remove(fermata) | La copia c'è, e il remove la cambia. Ma remove restituisce None, e domenica si attacca a quello: assert None == [...] | test_toglie_la_fermata |
L'ultima è la stessa di fermate = fermate.sort(): i metodi che cambiano la scatola restituiscono None. Una cosa per riga.
8 · Il piano della domenica
In italiano.
- Parto da un dizionario vuoto.
- Per ogni treno e i suoi orari:
- nel dizionario nuovo metto una lista nuova con gli stessi orari.
- Restituisco il dizionario nuovo.
def copia_piano(piano: dict[str, list[str]]) -> dict[str, list[str]]:
copia = {}
for treno, orari in piano.items():
copia[treno] = list(orari)
return copiaPasso per passo. Con dict(piano), il codice di partenza, il disegno è questo. Disegno solo le frecce del M12; quelle del M14 fanno la stessa cosa, verso ["06:15"].
Due dizionari, ma le liste degli orari sono in comune. Aggiungere un treno alla domenica cambia solo il suo dizionario: per questo due test sono verdi anche col bug. Togliere un orario segue la freccia, e arriva al sabato. Con la soluzione, ogni chiave della domenica ha la freccia verso una lista sua.
Va bene anche copy.deepcopy(piano), con import copy in cima al file.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return dict(piano) (il codice di partenza) | Copia il dizionario, non le liste dentro: la copia a metà | test_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove |
return piano.copy() | La stessa cosa di dict(piano), con un altro nome | test_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove |
Il ciclo, ma con copia[treno] = orari | Il ciclo c'è, ma copia le frecce: è dict(piano) scritto a mano | test_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove |
return piano | Nessuna copia: la domenica è il sabato con un altro nome | test_un_treno_in_piu_non_tocca_il_sabato, test_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove |
9 · Il quaderno dei guasti
In italiano.
- Il default è
None: «non mi hai dato un quaderno». - Se il quaderno è
None, ne preparo uno nuovo, qui, a ogni chiamata. - Scrivo il guasto nel quaderno, con
append: se il quaderno arriva da fuori, è giusto che cambi. - Restituisco il quaderno.
def segna_guasto(guasto: str, quaderno: list[str] | None = None) -> list[str]:
if quaderno is None:
quaderno = []
quaderno.append(guasto)
return quadernoPasso per passo. Due quaderni nuovi, come nell'ultimo test:
primo = segna_guasto("freno")
secondo = segna_guasto("luci")Con quaderno=[], il codice di partenza:
Con None il default è una scatola che non si cambia, e la lista nasce dentro la funzione: ogni chiamata ha la sua.
Con il codice di partenza, test_senza_quaderno_ne_comincia_uno è verde: la prima chiamata trova il default ancora vuoto. Il bug si vede solo dalla seconda. Per questo il test rosso è quello con due quaderni.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
quaderno=[] (il codice di partenza) | La lista del default nasce una volta sola: tutti i quaderni nuovi sono lo stesso quaderno | test_due_quaderni_nuovi_sono_separati |
if not quaderno: al posto di if quaderno is None: | Un quaderno vuoto che ti passano è «falso»: la funzione ne fa uno nuovo e scrive lì. Il quaderno del M14 resta vuoto | test_anche_in_un_quaderno_vuoto_che_gli_passi |
quaderno = quaderno + [guasto] al posto dell'append | + prepara una scatola nuova: il quaderno che ti hanno passato non riceve niente | test_scrive_nel_quaderno_che_gli_passi, test_anche_in_un_quaderno_vuoto_che_gli_passi |
La seconda è la stessa trappola di if listino.get(zona): nei dizionari: if not x non chiede «c'è?», chiede «è vuoto o falso?». Per sapere se un argomento manca, si chiede is None.
La storia
Livello 1 · Uguali o la stessa scatola?
In italiano.
- Parto da una lista vuota.
- Per ogni treno del deposito: se non è il treno
codicee i suoi vagoni sono la scatola ditreni[codice], lo aggiungo. - Restituisco la lista in ordine alfabetico.
def gemelli(treni: dict[str, list[str]], codice: str) -> list[str]:
trovati = []
for altro, vagoni in treni.items():
if altro != codice and vagoni is treni[codice]:
trovati.append(altro)
return sorted(trovati)Il disegno.
Nel registro vero, il foglio di stamattina:
M12 ['M16']
M14 []
M16 ['M12']
M18 ['M20']
M20 ['M18']Cinque treni sul foglio, tre scatole nel deposito. Il M12 e il M16 sono un treno solo con due nomi; il M18 e il M20 pure. Il M14 ha gli stessi vagoni del M12, ma è un'altra scatola: con == sarebbe sembrato un gemello anche lui.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
vagoni == treni[codice] al posto di is | Trova i treni uguali, non i gemelli. Sul registro vero il M14 diventa gemello del M12, e Sergio Colombo diventa un sospettato | test_livello_1_uguali_non_basta |
Senza altro != codice | Ogni treno è gemello di se stesso: in ogni risposta c'è un treno di troppo | Tutti e quattro i test del livello 1 |
return trovati senza sorted | L'ordine è quello del dizionario | test_livello_1_tutti_i_gemelli_in_ordine |
Livello 2 · Le mani sul deposito
In italiano.
- Prendo i vagoni del treno: un'etichetta sulla sua scatola, non una copia.
- Se l'azione è
"aggiungi",appenddel vagone. - Se è
"togli",removedel vagone: toglie il primo con quel nome. - Niente
return: il deposito è già cambiato.
def esegui(treni: dict[str, list[str]], operazione: dict) -> None:
vagoni = treni[operazione["treno"]]
if operazione["azione"] == "aggiungi":
vagoni.append(operazione["vagone"])
elif operazione["azione"] == "togli":
vagoni.remove(operazione["vagone"])È uguale al vecchio esegui: è l'unica funzione giusta del 2009. Qui l'alias è voluto: la funzione deve cambiare il deposito che riceve.
Nel registro vero, il M12:
22:00 Lucia Ferri nuovo -> motrice, carrozza, carrozza, motrice
22:20 Ivo Brambati aggiungi bici -> motrice, carrozza, carrozza, motrice, bici
22:25 Ivo Brambati togli bici -> motrice, carrozza, carrozza, motriceIvo dice la verità: la bici l'ha agganciata e l'ha tolta. Il M12 è tornato com'era alle 22:00.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
vagoni = vagoni + [operazione["vagone"]] | + prepara una scatola nuova e ci sposta l'etichetta della funzione: il deposito non vede niente | test_livello_2_aggiungi |
treni[codice] = treni[codice] + [...] | Il deposito cambia, ma con una scatola nuova. Chi aveva un'etichetta sulla vecchia (un gemello, una fotografia) non lo vede | test_livello_2_la_scatola_resta_la_stessa |
Livello 3 · Una scatola per ogni treno
In italiano. Nel deposito, alla chiave codice, metto una lista nuova con i vagoni del modello.
def come(treni: dict[str, list[str]], codice: str, modello: str) -> None:
treni[codice] = list(treni[modello])Va bene anche treni[modello].copy() o treni[modello][:].
Nel registro vero: con il tuo come, il M12 non ha più gemelli. Il vecchio come faceva treni[codice] = treni[modello]. Alle 22:40 Marta Villa ha fatto nascere il M16 come il M12, e il vecchio programma ha attaccato al M16 l'etichetta della scatola del M12:
Da quel momento, tutto quello che si fa al M16 succede anche al M12.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
treni[codice] = treni[modello] (il vecchio come) | Due chiavi, una scatola: il M16 è il M12 con un altro nome | test_livello_3_due_scatole, test_livello_3_il_modello_non_cambia |
return list(treni[modello]) | La copia c'è, ma nessuno la mette nel deposito: la funzione la restituisce, e rigioca la butta | Tutti e tre i test del livello 3 |
Livello 4 · Il treno vuoto
In italiano.
- Il default è
None. - Se non mi danno i vagoni, il treno ha una lista nuova, vuota, preparata qui.
- Se me li danno, il treno ha una copia della lista.
def nuovo(treni: dict[str, list[str]], codice: str, vagoni: list[str] | None = None) -> None:
if vagoni is None:
treni[codice] = []
else:
treni[codice] = list(vagoni)Perché la copia anche quando i vagoni ci sono? Perché arrivano da una riga del registro. Senza copia, il treno e la riga del registro sono la stessa scatola: ogni vagone agganciato al treno finisce anche nel registro. È per questo che il vecchio programma lavora su copy.deepcopy(REGISTRO): Fumagalli se n'era accorto, e ha messo una pezza fuori invece di correggere dentro.
Funziona anche vagoni=[] con treni[codice] = list(vagoni): la scatola del default non esce mai dalla funzione, esce solo una sua copia. Ma chi legge deve fare questo ragionamento; con None non serve.
Nel registro vero, la sezione 4 del quaderno si accende:
M12 motrice, carrozza, carrozza, motrice gemelli: []
M14 motrice, carrozza, carrozza, motrice, bici gemelli: []
M16 motrice, carrozza, carrozza, motrice, bici gemelli: []
M18 motrice, carrozza, motrice gemelli: []
M20 (vuoto) gemelli: []Il foglio giusto: il M12 senza bici, il M20 vuoto, due bici e non tre. Nel vecchio, il M18 e il M20 avevano avuto tutti e due la scatola del default, e i vagoni di Teresa erano finiti su tutti e due.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
vagoni=[] e treni[codice] = vagoni (il vecchio nuovo) | Due bug in uno: i treni vuoti condividono la scatola del default, quelli con i vagoni condividono la lista che ricevono | test_livello_4_i_vagoni_sono_una_copia, test_livello_4_due_treni_vuoti_due_scatole |
None giusto, ma treni[codice] = vagoni senza copia | I treni vuoti vanno bene; il treno e la lista che ricevi sono la stessa scatola | test_livello_4_i_vagoni_sono_una_copia |
Livello 5 · La fotografia delle 23
In italiano.
- Parto da un dizionario vuoto.
- Per ogni treno: nella foto, una lista nuova con i suoi vagoni.
- Restituisco la foto.
def fotografia(treni: dict[str, list[str]]) -> dict[str, list[str]]:
foto = {}
for codice, vagoni in treni.items():
foto[codice] = list(vagoni)
return fotoÈ l'esercizio 8 della palestra. Va bene anche copy.deepcopy(treni).
Nel registro vero, le due fotografie delle 23:
la vecchia la giusta
M12 motrice, carrozza, carrozza, motrice, bici motrice, carrozza, carrozza, motrice
M14 motrice, carrozza, carrozza, motrice, bici motrice, carrozza, carrozza, motrice
M16 motrice, carrozza, carrozza, motrice, bici motrice, carrozza, carrozza, motrice
M18 motrice, carrozza, motrice (vuoto)
M20 motrice, carrozza, motrice (vuoto)La vecchia fotografia è identica al foglio di stamattina. dict(treni) aveva copiato le frecce, non i treni: le liste erano quelle del deposito, e hanno continuato a cambiare fino alle 23:45. Alle 23:00, nella realtà, non c'era nessuna bici.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return dict(treni) (il vecchio fotografia) | La copia a metà: un treno nuovo non entra, ma un vagone nuovo sì | test_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove |
return treni.copy() | La stessa cosa, con un altro nome | test_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove |
Il ciclo, ma con foto[codice] = vagoni | Il ciclo copia le frecce: è dict(treni) scritto a mano | test_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove |
return treni | Nessuna foto: è il deposito con un altro nome | test_livello_5_un_treno_nuovo_non_entra_nella_foto, test_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove |
Il finale
- Livello 2: Ivo ha agganciato la bici al M12 alle 22:20 e l'ha tolta alle 22:25. Dice la verità.
- Livello 5: la fotografia delle 23 che lo accusa è falsa. Aveva le scatole in comune con il deposito, e mostra quello che è successo dopo, fino alle 23:45. Rifatta bene, alle 23 non c'era nessuna bici.
- Livelli 1 e 3: nel vecchio programma, dalle 22:40 il M12 e il M16 sono una scatola sola. Quello che si fa al M16 succede anche al M12.
- Il registro: dopo le 23 le bici chieste sono due. Alle 23:30 Giulia Ronchi ne aggancia una al M16, il suo treno. Alle 23:45 Sergio Colombo ne aggancia una al M14, che è uguale al M12 ma non è lo stesso (livello 1).
La bici di Giulia è finita nella scatola del M12 e del M16. Il foglio l'ha stampata due volte: una richiesta, due vagoni. Con quella di Sergio fanno tre, e il terzo è venuto dalle riparazioni.
La bici del M12 l'ha chiesta Giulia Ronchi. Per il M16, ed era giusto così.
python storia/verifica.py "Giulia Ronchi"