Vai al contenuto
code-to-code

Apro l'indice…

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

Python5. I dizionarip. 142

I dizionari, 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: 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-dizionari-soluzioni.zip19 KB

La palestra

1 · La biglietteria

In italiano. Chiedo al listino il prezzo della zona. Se la zona non c'è, la risposta è None.

Python
def prezzo_corsa(listino: dict[str, float], zona: str) -> float | None:
    return listino.get(zona)

get senza ripiego dà già None quando la chiave manca: non serve nessun if.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return listino[zona]Con «luna»: KeyError: 'luna', la macchinetta si bloccatest_zona_che_non_esiste_da_none
return listino.get(zona, 0)La luna costa 0 euro: un prezzo inventato, non «non c'è»test_zona_che_non_esiste_da_none
if listino.get(zona): return listino[zona]Una zona che costa 0.0 è «falsa» per l'if: la navetta gratis spariscetest_una_zona_gratis_non_e_una_zona_che_manca

La terza è la più subdola: if valore: non chiede «c'è?», chiede «è vero?». E 0, 0.0, "", [] e {} per Python sono falsi. Per sapere se una chiave c'è, si chiede con in, o si confronta con is None.


2 · Il tabellone

In italiano.

  1. Parto da una lista vuota.
  2. Per ogni stazione e la sua lucina:
  3. se la lucina è spenta, la stazione va nella lista.
  4. Alla fine la restituisco in ordine alfabetico.
Python
def stazioni_chiuse(stato: dict[str, bool]) -> list[str]:
    chiuse = []
    for stazione, aperta in stato.items():
        if not aperta:
            chiuse.append(stazione)
    return sorted(chiuse)

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return chiuse senza sortedL'ordine è quello del dizionario, non quello alfabeticotest_solo_le_chiuse_in_ordine_alfabetico
for stazione in stato: e poi if not stazione:Il for dà solo le chiavi: l'if guarda il nome della stazione, che non è mai vuoto. Nessuna stazione è chiusatest_solo_le_chiuse_in_ordine_alfabetico

Con il for sulle chiavi va bene anche if not stato[stazione]:. Con .items() è più leggibile: il valore ha già un nome.


3 · Il tornello

In italiano. È l'esempio B: per ogni badge, se l'ho già visto aggiungo uno, altrimenti parte da uno.

Python
def conta_timbrature(badge_letti: list[str]) -> dict[str, int]:
    conteggi = {}
    for badge in badge_letti:
        if badge in conteggi:
            conteggi[badge] = conteggi[badge] + 1
        else:
            conteggi[badge] = 1
    return conteggi

Va bene anche la versione corta: conteggi[badge] = conteggi.get(badge, 0) + 1.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Solo conteggi[badge] = conteggi[badge] + 1Al primo badge la chiave non c'è: KeyError: 'B-01'test_conta_ogni_badge, test_un_badge_solo
Solo conteggi[badge] = 1Nessun errore, ma ogni badge vale sempre 1test_conta_ogni_badge

4 · Chi è passato dove

In italiano.

  1. Per ogni coppia, la spacchetto: prima il badge, poi la stazione.
  2. Se la stazione non ha ancora una lista, gliene do una vuota.
  3. Sempre: aggiungo il badge alla lista della sua stazione.
Python
def per_stazione(timbrature: list[tuple[str, str]]) -> dict[str, list[str]]:
    gruppi = {}
    for badge, stazione in timbrature:
        if stazione not in gruppi:
            gruppi[stazione] = []
        gruppi[stazione].append(badge)
    return gruppi

Il disegno.

inizio per_stazione(timbrature) gruppi = {} per ogni badge, stazione in timbrature se stazione not in gruppi sì: gruppi[stazione] = [] gruppi[stazione].append(badge) restituisci gruppiper_stazione(timbrature)gruppi = {}per ogni badge, stazione intimbraturestazione not ingruppigruppi[stazione] = []gruppi[stazione].append(badge)restituisci gruppinosìfiniti
Una lista per stazione

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
gruppi[stazione] = [badge]A ogni giro la lista viene sostituita: resta solo l'ultimo badge di ogni stazionetest_raggruppa_nell_ordine_di_arrivo, test_lo_stesso_badge_due_volte_conta_due_volte
Solo gruppi[stazione].append(badge)La prima volta la lista non esiste: KeyError: 'Porta Codice'gli stessi due

5 · Il deposito dei treni

In italiano.

  1. Per ogni treno, prendo il suo codice.
  2. Se quel codice è già nel dizionario, mi fermo con un errore che dice quale.
  3. Altrimenti metto il treno nel dizionario, con il codice come chiave.
Python
def indice_per_codice(treni: list[dict]) -> dict[str, dict]:
    indice = {}
    for treno in treni:
        codice = treno["codice"]
        if codice in indice:
            raise ValueError(f"Codice duplicato: {codice}")
        indice[codice] = treno
    return indice

Il disegno.

inizio indice_per_codice(treni) indice = {} per ogni treno in treni codice = treno["codice"] se codice in indice sì: errore ValueError codice duplicato indice[codice] = treno restituisci indiceindice_per_codice(treni)indice = {}per ogni treno in trenicodice = treno["codice"]codice in indiceValueError codice duplicatoindice[codice] = trenorestituisci indicenosìfiniti
Il controllo dei codici doppi

Il controllo va prima di scrivere: dopo, il primo treno sarebbe già stato sovrascritto.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Nessun controllo sui doppioniIl secondo M12 prende il posto del primo, in silenziotest_codice_duplicato_e_un_errore
indice[treno] = trenoUn dizionario non può fare da chiave: TypeError: unhashable type: 'dict'test_dal_codice_al_treno, test_codice_duplicato_e_un_errore

6 · Il tabellone dei ritardi

In italiano.

  1. Parto da un dizionario nuovo, vuoto.
  2. Per ogni treno del tabellone, con i suoi minuti:
  3. scrivo nel nuovo dizionario i minuti più il suo ritardo; se non ne ha, zero.
Python
def applica_ritardi(tempi: dict[str, int], ritardi: dict[str, int]) -> dict[str, int]:
    aggiornati = {}
    for treno, minuti in tempi.items():
        aggiornati[treno] = minuti + ritardi.get(treno, 0)
    return aggiornati

Girare sui tempi risolve due problemi insieme: ogni treno del tabellone c'è, e i ritardi dei treni che non esistono non li incontri mai.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
aggiornati = tempi, poi le modificheUna scatola, due etichette: il tabellone appeso cambia anche luitest_il_tabellone_originale_non_cambia
Girare sui ritardi con tempi[treno] + ritardoIl ritardo di M99 cerca M99 nei tempi: KeyError: 'M99'test_i_treni_che_non_esistono_si_ignorano

7 · Gli oggetti smarriti

In italiano.

  1. Parto da una copia del primo deposito.
  2. Per ogni oggetto del secondo, con la sua quantità:
  3. quanti ne ho già (zero se è nuovo) più quanti ne arrivano.
Python
def unisci_depositi(primo: dict[str, int], secondo: dict[str, int]) -> dict[str, int]:
    unito = dict(primo)
    for oggetto, quanti in secondo.items():
        unito[oggetto] = unito.get(oggetto, 0) + quanti
    return unito

Passo per passo, con {"ombrello": 3, "guanto": 1} e {"ombrello": 2, "sciarpa": 4}:

Girooggetto, quantiunito.get(oggetto, 0)unito dopo il giro
prima——{"ombrello": 3, "guanto": 1} (la copia)
1"ombrello", 23{"ombrello": 5, "guanto": 1}
2"sciarpa", 40{"ombrello": 5, "guanto": 1, "sciarpa": 4}

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return {**primo, **secondo}Le due stelle aprono i dizionari uno dopo l'altro: per «ombrello» vince il secondo, 2. Non sommatest_somma_gli_oggetti_in_comune
unito = primoIl deposito di Porta Codice viene modificatotest_i_depositi_di_partenza_non_cambiano

8 · La stazione più affollata

In italiano.

  1. Il migliore, all'inizio, non c'è.
  2. Scorro le stazioni in ordine alfabetico.
  3. Se non ho ancora un migliore, o questa stazione ha più passaggi del migliore, diventa lei il migliore.
  4. Alla fine restituisco il migliore: se il dizionario era vuoto, è ancora None.
Python
def stazione_piu_affollata(passaggi: dict[str, int]) -> str | None:
    migliore = None
    for stazione in sorted(passaggi):
        if migliore is None or passaggi[stazione] > passaggi[migliore]:
            migliore = stazione
    return migliore

Il disegno.

inizio stazione_piu_affollata(passaggi) migliore = None per ogni stazione in sorted(passaggi) se nessun migliore o più passaggi sì: migliore = stazione restituisci migliorestazione_piu_affollata(passaggi)migliore = Noneper ogni stazione insorted(passaggi)nessun migliore opiù passaggimigliore = stazionerestituisci migliorenosìfiniti
La stazione più affollata

Passo per passo, con {"Ponte Ciclo": 50, "Largo Lista": 50, "Via Variabile": 10}. sorted dà le chiavi in ordine alfabetico: Largo Lista, Ponte Ciclo, Via Variabile.

GirostazionePassaggiConfrontomigliore dopo il giro
1Largo Lista50migliore è NoneLargo Lista
2Ponte Ciclo5050 > 50? NoLargo Lista
3Via Variabile1010 > 50? NoLargo Lista

Il pari merito si risolve da solo: con > (e non >=) il primo in ordine alfabetico non viene mai scavalcato da uno uguale.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return max(passaggi, key=passaggi.get)Corto ed elegante, ma a pari merito vince il primo inserito, non il primo in ordine alfabetico. E con il dizionario vuoto: ValueError: max() iterable argument is emptytest_pari_merito_vince_l_ordine_alfabetico, test_nessun_dato
Partire da massimo = 0Una stazione con zero passaggi non supera mai zero: risposta Nonetest_anche_con_zero_passaggi_una_stazione_c_e

La seconda è la trappola di piu_alta in Liste e cicli: il punto di partenza è il primo elemento, non un numero inventato.


La storia

Livello 1 · La rubrica

In italiano. Per ogni persona, nel dizionario: chiave il badge, valore il nome.

Python
def rubrica(persone: list[dict]) -> dict[str, str]:
    elenco = {}
    for persona in persone:
        elenco[persona["badge"]] = persona["nome"]
    return elenco

Nel registro vero: B-03 è di Nadia Russo, guardia giurata.


Livello 2 · Il conto

In italiano. Come il tornello, ma il badge sta dentro la timbratura.

Python
def quante_timbrature(timbrature: list[dict]) -> dict[str, int]:
    conteggi = {}
    for timbratura in timbrature:
        badge = timbratura["badge"]
        if badge in conteggi:
            conteggi[badge] = conteggi[badge] + 1
        else:
            conteggi[badge] = 1
    return conteggi

Nel registro vero: B-03 ha timbrato 4 volte.


Livello 3 · I percorsi

In italiano. Raggruppo le timbrature intere per badge; l'ordine resta quello del registro, perché l'append aggiunge in fondo.

Python
def percorsi(timbrature: list[dict]) -> dict[str, list[dict]]:
    tragitti = {}
    for timbratura in timbrature:
        badge = timbratura["badge"]
        if badge not in tragitti:
            tragitti[badge] = []
        tragitti[badge].append(timbratura)
    return tragitti

Nel registro vero, il percorso di B-03:

22:00 Porta Codice  entrata
00:32 Porta Codice  uscita
00:33 Vecchia Fiera entrata
00:48 Vecchia Fiera uscita

Un minuto tra Porta Codice e Vecchia Fiera. Qualcosa non torna.

La trappola. Con tragitti[badge] = [timbratura] ogni badge tiene solo la sua ultima timbratura. Il test del livello 3 diventa rosso, e con lui tre test del livello 5, che usa percorsi: un errore in una funzione si porta dietro tutte quelle che la usano. Se il livello 5 è rosso senza motivo, controlla prima il 3.


Livello 4 · Chi è ancora dentro

In italiano.

  1. Ogni badge ha un saldo che parte da zero.
  2. Entrata: +1. Uscita: −1.
  3. Alla fine tengo i badge con il saldo sopra zero, in ordine alfabetico.
Python
def ancora_dentro(timbrature: list[dict]) -> list[str]:
    saldo = {}
    for timbratura in timbrature:
        badge = timbratura["badge"]
        if badge not in saldo:
            saldo[badge] = 0
        if timbratura["verso"] == "entrata":
            saldo[badge] = saldo[badge] + 1
        else:
            saldo[badge] = saldo[badge] - 1
    dentro = []
    for badge, conto in saldo.items():
        if conto > 0:
            dentro.append(badge)
    return sorted(dentro)

Due schemi in fila: prima contare, poi setacciare il risultato.

Nel registro vero: ancora dentro B-05 e B-08.

La trappola. Tenere «chi è entrato almeno una volta» invece del saldo: dentro finiscono tutti. Rossi: test_livello_4_chi_ha_piu_entrate_che_uscite, test_livello_4_tutti_usciti.


Livello 5 · Il badge impossibile

In italiano.

  1. Per ogni badge prendo il suo percorso (livello 3).
  2. Confronto ogni timbratura con quella prima.
  3. Se la stazione cambia e sono passati meno di cinque minuti, il badge è sospetto.
  4. Ogni sospetto una volta sola; alla fine in ordine alfabetico.
Python
def badge_impossibili(timbrature: list[dict]) -> list[str]:
    sospetti = []
    for badge, tragitto in percorsi(timbrature).items():
        for i in range(1, len(tragitto)):
            prima = tragitto[i - 1]
            dopo = tragitto[i]
            cambia_stazione = prima["stazione"] != dopo["stazione"]
            attesa = minuti(dopo["ora"]) - minuti(prima["ora"])
            if cambia_stazione and attesa < MINUTI_TRA_STAZIONI and badge not in sospetti:
                sospetti.append(badge)
    return sorted(sospetti)

Il range parte da 1, non da 0: la prima timbratura non ha una «prima» con cui confrontarsi.

Passo per passo, sul percorso di B-03:

iprimadopoCambia stazione?AttesaSospetto?
122:00 Porta Codice00:32 Porta Codiceno152no
200:32 Porta Codice00:33 Vecchia Fierasì1sì
300:33 Vecchia Fiera00:48 Vecchia Fierano15no (e c'è già)

Nel registro vero: l'unico badge impossibile è B-03. Nadia Russo è uscita da Porta Codice alle 00:32; un minuto dopo «lei» entrava a Vecchia Fiera. Il badge ha un gemello.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
attesa <= MINUTI_TRA_STAZIONICinque minuti esatti diventano impossibili: Sergio Colombo, che va da Largo Lista a Ponte Ciclo in cinque minuti, finisce tra i sospettitest_livello_5_cinque_minuti_bastano
Nessun controllo sulla stazioneUscire e rientrare dallo stesso tornello in un minuto diventa un viaggio impossibiletest_livello_5_la_stessa_stazione_non_e_un_viaggio, test_livello_5_due_stazioni_in_due_minuti
Senza badge not in sospettiUn badge con due salti sospetti compare due voltetest_livello_5_ogni_badge_una_volta_sola_e_in_ordine

Livello 6 · Chi è entrato lì vicino

In italiano.

  1. Trasformo in minuti l'inizio e la fine dell'intervallo.
  2. Per ogni timbratura, la tengo se: è un'entrata, e la stazione è tra quelle cercate, e l'ora (in minuti) sta tra inizio e fine, estremi compresi.
Python
def entrati_tra(timbrature: list[dict], stazioni: list[str], da: str, a: str) -> list[str]:
    inizio = minuti(da)
    fine = minuti(a)
    entrati = []
    for timbratura in timbrature:
        quando = minuti(timbratura["ora"])
        if (
            timbratura["verso"] == "entrata"
            and timbratura["stazione"] in stazioni
            and inizio <= quando <= fine
        ):
            entrati.append(timbratura["badge"])
    return entrati

inizio <= quando <= fine è un modo di Python per scrivere inizio <= quando and quando <= fine. Le parentesi intorno all'if servono solo per andare a capo.

Nel registro vero, tra le 00:48 e le 00:58 a Ponte Ciclo o Piazza Query entra un badge solo: B-08, alle 00:53 a Ponte Ciclo.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
da <= timbratura["ora"] <= a sulle stringheFunziona per caso finché non si passa la mezzanotte: tra «23:50» e «00:10» le 23:55 non ci sono piùtest_livello_6_a_cavallo_della_mezzanotte
< al posto di <=Chi entra proprio all'ora di inizio o di fine viene esclusotest_livello_6_gli_estremi_sono_compresi
Nessun controllo sul versoEntrano anche le uscitetest_livello_6_le_uscite_non_contano, test_livello_6_solo_le_entrate_nelle_stazioni_giuste

Il finale

  1. Livello 5: il badge B-03 è stato in due posti insieme. È di Nadia Russo (livello 1), ma alle 00:32 lei usciva da Porta Codice: è il suo badge, non è lei. Qualcuno ha un clone.
  2. Livello 3: il clone entra a Vecchia Fiera alle 00:33 ed esce alle 00:48. La Chiave Rossa sparisce alle 00:40: in mezzo.
  3. Livello 6: nei dieci minuti dopo, nelle stazioni vicine entra solo B-08, alle 00:53 a Ponte Ciclo. Pietro Galli rientra alle 00:51, ma a Largo Lista, che non è vicina. Ivo Brambati entra a Piazza Query, ma alle 01:10: troppo tardi.
  4. Livello 2 e 4: B-08 a fine notte è ancora dentro. Elena Marchi pure, ma non si è mai mossa da Via Variabile: il suo turno finisce alle 5.

B-08 è di Dario Sala, l'elettricista: l'unico che sa cosa farsene di una chiave del quadro elettrico.

Terminale
python storia/verifica.py "Dario Sala"