Vai al contenuto
code-to-code

Apro l'indice…

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

Python8. Etichette e scatolep. 249

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.

python-etichette-e-scatole-soluzioni.zip20 KB

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:

fermate = ["Porta Codice", "Via Variabile", "Largo Lista"] cartello = fermatefermatecartellolist"Porta Codice"0"Via Variabile"1"Largo Lista"2
Alla fine, due etichette e una scatola
  • 1A · ["Porta Codice", "Via Variabile", "Largo Lista"]
  • 1B · 1

Passo per passo.

  1. Riga 1: una scatola, un'etichetta.
  2. Riga 2: nessuna scatola nuova. cartello si attacca alla scatola di fermate.
  3. Riga 3: la scatola riceve "Largo Lista". È l'unica.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
1A ["Porta Codice", "Via Variabile"]Hai letto cartello = fermate come una copia. Il bug di tutto il capitolotest_disegno_1_fermate
1B 2Hai contato le etichette, non le scatoletest_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.

treno = ["motrice", "carrozza"] riserva = trenotrenoriservalist"motrice"0"carrozza"1
Dopo la riga 2, riserva = treno
riserva = ["motrice", "carrozza"] treno = ["motrice", "bici"]riservatrenolist"motrice"0"carrozza"1list"motrice"0"bici"1
Dopo la riga 3, treno = ["motrice", "bici"]
riserva = ["motrice", "carrozza"] treno = ["motrice", "bici", "motrice"]riservatrenolist"motrice"0"carrozza"1list"motrice"0"bici"1"motrice"2
Dopo la riga 4, treno.append("motrice")
  • 2A · ["motrice", "carrozza"]
  • 2B · 2

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
2A ["motrice", "bici", "motrice"]Hai pensato che riserva segua treno. Ma un'etichetta non segue un'altra etichetta: è attaccata a una scatolatest_disegno_2_riserva
2A ["motrice", "carrozza", "motrice"]Hai fatto lavorare l'append sulla scatola vecchia. Alla riga 4, però, treno è già sulla scatola nuovatest_disegno_2_riserva
2B 1Hai pensato che = cambi il contenuto della scatola. = prepara una scatola nuova e ci sposta l'etichettatest_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.

  1. liberi -= 3 vuol dire liberi = liberi - 3: una scatola nuova, il 5, e l'etichetta liberi ci va sopra. Il numero 8 non si tocca.
  2. replace non cambia la stringa: ne restituisce una nuova, e = ci sposta display.
  3. remove cambia la lista. E la lista è una sola.

Il disegno, alla fine:

posti = 8 liberi = 5 annuncio = "treno in arrivo" display = "treno in partenza" panchine = ["A", "C"] occupate = panchinepostiliberiannunciodisplaypanchineoccupateint8int5str"treno in arrivo"str"treno in partenza"list"A"0"C"1
Alla fine: numero, stringa e lista
  • 3A · 8
  • 3B · "treno in arrivo"
  • 3C · ["A", "C"]

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
3A 5Hai trattato il numero come una lista. Un int non si cambia: -= fa una scatola nuovatest_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 nuovatest_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.

mattina = ["Porta Codice", "Piazza Query"] notte = mattina sera = ["Porta Codice", "Piazza Query"] festivo = ["Porta Codice", "Piazza Query"]mattinanotteserafestivolist"Porta Codice"0"Piazza Query"1list"Porta Codice"0"Piazza Query"1list"Porta Codice"0"Piazza Query"1
Dopo le quattro righe
mattina = ["Porta Codice", "Piazza Query", "Vecchia Fiera"] notte = mattina sera = ["Porta Codice", "Piazza Query"] festivo = ["Porta Codice", "Piazza Query"]mattinanotteserafestivolist"Porta Codice"0"Piazza Query"1"Vecchia Fiera"2list"Porta Codice"0"Piazza Query"1list"Porta Codice"0"Piazza Query"1
Dopo notte.append("Vecchia Fiera")
  • 4A · True: stesso contenuto.
  • 4B · False: due scatole.
  • 4C · True: una scatola, due etichette.
  • 4D · True: l'append ha cambiato la scatola di mattina e notte. festivo è una copia fatta prima, e sera non c'entra.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
4A FalseHai pensato che == chieda «la stessa lista?». Chiede «lo stesso contenuto?»test_disegno_4_uguali
4B TrueHai usato is come ==. Due liste scritte uguali sono due scatoletest_disegno_4_la_stessa_mattina_e_sera
4C FalseHai letto notte = mattina come una copiatest_disegno_4_la_stessa_notte_e_mattina
4D FalseHai fatto arrivare Vecchia Fiera anche a festivo. Ma list(mattina) ha preparato una scatola nuova, e da lì in poi è per conto suotest_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:

binari = [["M12", "M14", "M18"], ["M16"]] _m20 = ["M20"] domani = [binari[0], binari[1], _m20]binaridomanilist01list"M12"0"M14"1"M18"2list"M16"0list012list"M20"0
Alla fine: cinque scatole
  • 5A · [["M12", "M14", "M18"], ["M16"]]
  • 5B · True
  • 5C · 5: le due esterne, i due binari in comune, il binario del M20.

Passo per passo.

  1. Riga 1: tre scatole. L'esterna di binari e i due binari.
  2. Riga 2: una scatola in più, l'esterna di domani, con due frecce copiate. Quattro scatole.
  3. Riga 3: domani[0] è il binario del M12, quello di tutti e due. Riceve il M18.
  4. Riga 4: una scatola nuova, ["M20"], e una freccia in più nell'esterna di domani. Cinque scatole.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
5A [["M12", "M14"], ["M16"]]Hai pensato che list() copi tutto, anche dentro. Copia un piano solotest_disegno_5_binari
5A [["M12", "M14", "M18"], ["M16"], ["M20"]]Hai trattato domani come un'altra etichetta su binari. La scatola esterna, invece, è nuovatest_disegno_5_binari
5B FalseLe esterne sono due, ma le frecce dentro portano allo stesso binariotest_disegno_5_lo_stesso_binario
5C 7Hai contato i binari due volte, una per ogni lista esterna. Conta le scatole, non le freccetest_disegno_5_quante_liste

6 · La lista entra nella funzione

In italiano.

  1. La chiamata attacca vagoni alla scatola di treno.
  2. vagoni.append("bici") cambia quella scatola: fuori, treno ha la bici.
  3. vagoni = ["motrice"] sposta l'etichetta della funzione su una scatola nuova. treno resta dov'era.
  4. vagoni.append("carrozza") lavora sulla scatola nuova.
  5. 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 sbagliataCosa succedeIl test rosso
6A ["motrice", "carrozza", "motrice"]Hai pensato che la funzione riceva una copia. Riceve un'etichetta sulla stessa scatolatest_disegno_6_treno
6A ["motrice", "carrozza"]Hai pensato che vagoni = … cambi anche treno. Dentro la funzione = sposta solo l'etichetta della funzionetest_disegno_6_treno
6B 4Hai contato i vagoni di treno. Ma al return, vagoni è già sulla scatola nuovatest_disegno_6_quanti

7 · La deviazione

In italiano.

  1. Prima di tutto, una scatola nuova con lo stesso contenuto del percorso.
  2. Tolgo la fermata dalla scatola nuova.
  3. Restituisco la scatola nuova.
Python
def senza_fermata(percorso: list[str], fermata: str) -> list[str]:
    domenica = list(percorso)
    domenica.remove(fermata)
    return domenica

Passo 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 sbagliatoCosa succedeIl test rosso
domenica = percorso (il codice di partenza)Due etichette, una scatola: il remove arriva al ferialetest_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 ferialetest_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.

  1. Parto da un dizionario vuoto.
  2. Per ogni treno e i suoi orari:
  3. nel dizionario nuovo metto una lista nuova con gli stessi orari.
  4. Restituisco il dizionario nuovo.
Python
def copia_piano(piano: dict[str, list[str]]) -> dict[str, list[str]]:
    copia = {}
    for treno, orari in piano.items():
        copia[treno] = list(orari)
    return copia

Passo 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"].

sabato = {"M12": ["06:00", "06:30"]} domenica = dict(sabato)sabatodomenicadict"M12"list"06:00"0"06:30"1dict"M12"
Dopo dict(piano), le frecce del M12

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 sbagliatoCosa succedeIl 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 nometest_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove
Il ciclo, ma con copia[treno] = orariIl ciclo c'è, ma copia le frecce: è dict(piano) scritto a manotest_togliere_una_corsa_non_tocca_il_sabato, test_le_liste_degli_orari_sono_nuove
return pianoNessuna copia: la domenica è il sabato con un altro nometest_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.

  1. Il default è None: «non mi hai dato un quaderno».
  2. Se il quaderno è None, ne preparo uno nuovo, qui, a ogni chiamata.
  3. Scrivo il guasto nel quaderno, con append: se il quaderno arriva da fuori, è giusto che cambi.
  4. Restituisco il quaderno.
Python
def segna_guasto(guasto: str, quaderno: list[str] | None = None) -> list[str]:
    if quaderno is None:
        quaderno = []
    quaderno.append(guasto)
    return quaderno

Passo per passo. Due quaderni nuovi, come nell'ultimo test:

Python
primo = segna_guasto("freno")
secondo = segna_guasto("luci")

Con quaderno=[], il codice di partenza:

default_di_segna_guasto = ["freno", "luci"] primo = default_di_segna_guasto secondo = default_di_segna_guastodefault_di_segna_guastoprimosecondolist"freno"0"luci"1
Con quaderno=[] nel default

Con None il default è una scatola che non si cambia, e la lista nasce dentro la funzione: ogni chiamata ha la sua.

default_di_segna_guasto = None primo = ["freno"] secondo = ["luci"]default_di_segna_guastoprimosecondoNoneTypeNonelist"freno"0list"luci"0
Con None nel default

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 sbagliatoCosa succedeIl test rosso
quaderno=[] (il codice di partenza)La lista del default nasce una volta sola: tutti i quaderni nuovi sono lo stesso quadernotest_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 vuototest_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 nientetest_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.

  1. Parto da una lista vuota.
  2. Per ogni treno del deposito: se non è il treno codice e i suoi vagoni sono la scatola di treni[codice], lo aggiungo.
  3. Restituisco la lista in ordine alfabetico.
Python
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.

inizio gemelli(treni, codice) trovati = [] per ogni altro, vagoni in treni.items() se altro != codice and vagoni is treni[codice] sì: trovati.append(altro) restituisci sorted(trovati)gemelli(treni, codice)trovati = []per ogni altro, vagoni intreni.items()altro != codice andvagoni istreni[codice]trovati.append(altro)restituisci sorted(trovati)nosìfiniti
Chi è gemello?

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 sbagliatoCosa succedeIl test rosso
vagoni == treni[codice] al posto di isTrova i treni uguali, non i gemelli. Sul registro vero il M14 diventa gemello del M12, e Sergio Colombo diventa un sospettatotest_livello_1_uguali_non_basta
Senza altro != codiceOgni treno è gemello di se stesso: in ogni risposta c'è un treno di troppoTutti e quattro i test del livello 1
return trovati senza sortedL'ordine è quello del dizionariotest_livello_1_tutti_i_gemelli_in_ordine

Livello 2 · Le mani sul deposito

In italiano.

  1. Prendo i vagoni del treno: un'etichetta sulla sua scatola, non una copia.
  2. Se l'azione è "aggiungi", append del vagone.
  3. Se è "togli", remove del vagone: toglie il primo con quel nome.
  4. Niente return: il deposito è già cambiato.
Python
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, motrice

Ivo dice la verità: la bici l'ha agganciata e l'ha tolta. Il M12 è tornato com'era alle 22:00.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
vagoni = vagoni + [operazione["vagone"]]+ prepara una scatola nuova e ci sposta l'etichetta della funzione: il deposito non vede nientetest_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 vedetest_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.

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

_vagoni = ["motrice", "carrozza", "carrozza", "motrice"] treni = {"M12": _vagoni, "M16": _vagoni}trenidict"M12""M16"list"motrice"0"carrozza"1"carrozza"2"motrice"3
Il deposito del vecchio programma, dopo le 22:40

Da quel momento, tutto quello che si fa al M16 succede anche al M12.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
treni[codice] = treni[modello] (il vecchio come)Due chiavi, una scatola: il M16 è il M12 con un altro nometest_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 buttaTutti e tre i test del livello 3

Livello 4 · Il treno vuoto

In italiano.

  1. Il default è None.
  2. Se non mi danno i vagoni, il treno ha una lista nuova, vuota, preparata qui.
  3. Se me li danno, il treno ha una copia della lista.
Python
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)
inizio nuovo(treni, codice, vagoni=None) se vagoni is None sì: treni[codice] = [] no: treni[codice] = list(vagoni) finenuovo(treni, codice,vagoni=None)vagoni is Nonetreni[codice] = list(vagoni)treni[codice] = []finenosì
Il treno vuoto

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 sbagliatoCosa succedeIl 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 ricevonotest_livello_4_i_vagoni_sono_una_copia, test_livello_4_due_treni_vuoti_due_scatole
None giusto, ma treni[codice] = vagoni senza copiaI treni vuoti vanno bene; il treno e la lista che ricevi sono la stessa scatolatest_livello_4_i_vagoni_sono_una_copia

Livello 5 · La fotografia delle 23

In italiano.

  1. Parto da un dizionario vuoto.
  2. Per ogni treno: nella foto, una lista nuova con i suoi vagoni.
  3. Restituisco la foto.
Python
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 sbagliatoCosa succedeIl 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 nometest_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove
Il ciclo, ma con foto[codice] = vagoniIl ciclo copia le frecce: è dict(treni) scritto a manotest_livello_5_un_vagone_nuovo_non_entra_nella_foto, test_livello_5_le_scatole_dentro_sono_nuove
return treniNessuna foto: è il deposito con un altro nometest_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

  1. Livello 2: Ivo ha agganciato la bici al M12 alle 22:20 e l'ha tolta alle 22:25. Dice la verità.
  2. 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.
  3. 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.
  4. 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ì.

Terminale
python storia/verifica.py "Giulia Ronchi"