Vai al contenuto
code-to-code

Apro l'indice…

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

Prontuario Python5. I dizionari

I dizionari

get, in, keys, values, items, pop, update, setdefault e gli schemi per contare, raggruppare e ordinare

Un dizionario trova le cose per nome, non per posizione: a ogni chiave corrisponde un valore, come un'etichetta attaccata alla sua scatola. Ogni voce dice a cosa serve un'operazione, mostra un esempio da provare e la cosa da ricordare. Nel codice, # → dice cosa vale quella riga, o cosa stampa. Il disegno con le chiavi e i valori, e il perché di tutto, sono nel capitolo I dizionari.

Creare un dizionario

Tra graffe, una coppia chiave: valore dopo l'altra, separate da virgole.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni  # → {'M12': 4, 'M14': 3, 'M16': 6}

vuoto = {}
vuoto  # → {}

dict([("M12", 4), ("M14", 3)])  # → {'M12': 4, 'M14': 3}
{"M12": 4, "M12": 5}  # → {'M12': 5}
{["M12"]: 4}  # → TypeError: unhashable type: 'list'

Le chiavi sono uniche: se scrivi due volte la stessa chiave, vince l'ultimo valore. Una chiave deve essere un valore che non cambia (un testo, un numero, una tupla); il valore invece può essere qualsiasi cosa, anche una lista o un altro dizionario. Python ricorda l'ordine in cui hai messo le chiavi.

d[chiave] e il KeyError

Con le quadre chiedi il valore di una chiave. Se la chiave non c'è, il programma si ferma con KeyError, e il messaggio ti dice quale chiave mancava.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni["M14"]  # → 3
vagoni["M99"]  # → KeyError: 'M99'
vagoni["m14"]  # → KeyError: 'm14'
vagoni[0]  # → KeyError: 0

Usa le quadre quando la chiave deve esserci: se manca è un bug, ed è giusto che il programma si fermi. Quando può mancare davvero, usa get (la voce dopo).

get()

La stessa domanda delle quadre, ma senza fermarsi: se la chiave non c'è, get risponde None, oppure il ripiego che gli passi come secondo argomento.

Python
vagoni = {"M12": 4, "M14": 3}
vagoni.get("M14")  # → 3
vagoni.get("M99")  # → None
vagoni.get("M99", 0)  # → 0
vagoni  # → {'M12': 4, 'M14': 3}

get non aggiunge niente: il ripiego è solo la risposta, il dizionario resta com'era.

in

Chiede se una chiave c'è. Risponde True o False, e non si ferma mai con un errore.

Python
vagoni = {"M12": 4, "M14": 3}
"M12" in vagoni  # → True
"M99" in vagoni  # → False
"M99" not in vagoni  # → True
4 in vagoni  # → False
4 in vagoni.values()  # → True

Aggiungere e cambiare

d[chiave] = valore scrive nel dizionario. Se la chiave non c'è la crea, se c'è già sostituisce il valore, senza avvisare.

Python
vagoni = {"M12": 4}
vagoni["M14"] = 3
vagoni  # → {'M12': 4, 'M14': 3}
vagoni["M12"] = 5
vagoni  # → {'M12': 5, 'M14': 3}
vagoni["M14"] = vagoni["M14"] + 1
vagoni  # → {'M12': 5, 'M14': 4}
vagoni["M99"] += 1  # → KeyError: 'M99'

Le chiavi nuove vanno in fondo; quelle che cambi restano al loro posto. Per aggiungere 1 la chiave deve già esserci, perché prima Python legge il valore vecchio: per contare da zero c'è lo schema con get.

keys()

Le chiavi del dizionario. Python te le dà come una vista, dict_keys([...]): per avere una lista vera c'è list(...).

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni.keys()  # → dict_keys(['M12', 'M14', 'M16'])
list(vagoni.keys())  # → ['M12', 'M14', 'M16']
list(vagoni)  # → ['M12', 'M14', 'M16']

for treno in vagoni:
    print(treno)
# → M12
# → M14
# → M16

Il for su un dizionario dà già le chiavi: for treno in vagoni e for treno in vagoni.keys() fanno la stessa cosa. Per questo keys() si scrive di rado.

values()

Solo i valori, senza le chiavi. Serve quando ti interessa il totale, il massimo, la media, e non di chi sono.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni.values()  # → dict_values([4, 3, 6])
list(vagoni.values())  # → [4, 3, 6]
sum(vagoni.values())  # → 13
max(vagoni.values())  # → 6
3 in vagoni.values()  # → True

for numero in vagoni.values():
    print(numero)
# → 4
# → 3
# → 6

max(vagoni.values()) ti dice quanto vale il più alto, non di chi è. Per sapere quale treno ha più vagoni c'è la chiave con il valore più alto.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni.values()[0]  # → TypeError: 'dict_values' object is not subscriptable
list(vagoni.values())[0]  # → 4

items()

Le coppie chiave e valore, ognuna in una tupla. È il modo per avere tutte e due le cose nello stesso for.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni.items()  # → dict_items([('M12', 4), ('M14', 3), ('M16', 6)])
list(vagoni.items())  # → [('M12', 4), ('M14', 3), ('M16', 6)]

for treno, numero in vagoni.items():
    print(treno, "ha", numero, "vagoni")
# → M12 ha 4 vagoni
# → M14 ha 3 vagoni
# → M16 ha 6 vagoni

Nel for ogni coppia si spacchetta in due etichette: la prima prende la chiave, la seconda il valore. I nomi li scegli tu, e for treno, numero si legge meglio di for k, v. Come funziona lo spacchettamento: Insiemi e tuple.

Python
vagoni = {"M12": 4, "M14": 3}
for treno, numero in vagoni:
    print(treno, numero)
# → ValueError: too many values to unpack (expected 2)

pop() e del

Tolgono una chiave, con il suo valore. pop ti consegna il valore che toglie, del lo toglie e basta.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
vagoni.pop("M14")  # → 3
vagoni  # → {'M12': 4, 'M16': 6}
del vagoni["M12"]
vagoni  # → {'M16': 6}

vagoni.pop("M99")  # → KeyError: 'M99'
del vagoni["M99"]  # → KeyError: 'M99'
vagoni.pop("M99", None)  # → None

Se la chiave non c'è, tutti e due si fermano con KeyError. Controlla prima con if "M99" in vagoni:, oppure dai a pop un ripiego come secondo argomento.

update()

Copia dentro un dizionario le coppie di un altro: le chiavi nuove si aggiungono, quelle che c'erano già prendono il valore nuovo.

Python
vagoni = {"M12": 4, "M14": 3}
vagoni.update({"M14": 5, "M16": 6})
vagoni  # → {'M12': 4, 'M14': 5, 'M16': 6}

{"M12": 4} | {"M14": 3}  # → {'M12': 4, 'M14': 3}

Con | ottieni invece un dizionario nuovo, e i due di partenza restano come sono.

Python
vagoni = {"M12": 4}
vagoni = vagoni.update({"M14": 3})
vagoni  # → None

setdefault()

«Dammi il valore di questa chiave; se non c'è, prima mettici questo.» A differenza di get, la chiave la aggiunge davvero.

Python
gruppi = {"Largo Lista": ["Lucia"]}
gruppi.setdefault("Largo Lista", [])  # → ['Lucia']
gruppi.setdefault("Ponte Ciclo", [])  # → []
gruppi  # → {'Largo Lista': ['Lucia'], 'Ponte Ciclo': []}

gruppi.setdefault("Ponte Ciclo", []).append("Ivo")
gruppi  # → {'Largo Lista': ['Lucia'], 'Ponte Ciclo': ['Ivo']}

Serve soprattutto per raggruppare: in una riga sola crea la lista vuota la prima volta e ci aggiunge l'elemento.

Contare

Quante volte compare ogni cosa. La chiave è la cosa, il valore è quante volte l'hai vista.

Python
badge_letti = ["B-01", "B-02", "B-01", "B-03", "B-01"]
conteggi = {}
for badge in badge_letti:
    conteggi[badge] = conteggi.get(badge, 0) + 1
conteggi  # → {'B-01': 3, 'B-02': 1, 'B-03': 1}

La prima volta che vede un badge, get risponde con il ripiego 0, e il conto parte da 1. Le volte dopo risponde con il conto fin lì. È lo schema del capitolo, quello con if ed else, scritto in una riga.

Python
conteggi = {}
conteggi["B-01"] += 1  # → KeyError: 'B-01'
Python
from collections import Counter
conteggi = Counter(["B-01", "B-02", "B-01", "B-03", "B-01"])
conteggi["B-01"]  # → 3
conteggi.most_common(1)  # → [('B-01', 3)]

Raggruppare in liste

Una lista per ogni chiave: per esempio, chi è salito a ogni fermata. La domanda nel mezzo è sempre la stessa: «è la prima volta che vedo questa chiave?».

Python
salite = [("Lucia", "Largo Lista"), ("Ivo", "Ponte Ciclo"), ("Marta", "Largo Lista")]
gruppi = {}
for nome, fermata in salite:
    if fermata not in gruppi:
        gruppi[fermata] = []
    gruppi[fermata].append(nome)
gruppi  # → {'Largo Lista': ['Lucia', 'Marta'], 'Ponte Ciclo': ['Ivo']}

La prima volta crei la lista vuota, poi, sempre, aggiungi. Con setdefault le due cose stanno in una riga:

Python
salite = [("Lucia", "Largo Lista"), ("Ivo", "Ponte Ciclo"), ("Marta", "Largo Lista")]
gruppi = {}
for nome, fermata in salite:
    gruppi.setdefault(fermata, []).append(nome)
gruppi  # → {'Largo Lista': ['Lucia', 'Marta'], 'Ponte Ciclo': ['Ivo']}
Python
gruppi = {}
gruppi["Largo Lista"].append("Lucia")  # → KeyError: 'Largo Lista'

Ordinare per valore

sorted su un dizionario ordina le chiavi. Per ordinare per valore, ordini le coppie di items() e con key gli dici di guardare il secondo pezzo di ogni coppia, cioè il valore.

Python
ore = {"Lucia": 31, "Sergio": 38, "Marta": 26}
sorted(ore)  # → ['Lucia', 'Marta', 'Sergio']
sorted(ore.items(), key=lambda coppia: coppia[1])  # → [('Marta', 26), ('Lucia', 31), ('Sergio', 38)]
sorted(ore.items(), key=lambda coppia: coppia[1], reverse=True)  # → [('Sergio', 38), ('Lucia', 31), ('Marta', 26)]
sorted(ore.items(), key=lambda coppia: coppia[1], reverse=True)[:2]  # → [('Sergio', 38), ('Lucia', 31)]
dict(sorted(ore.items(), key=lambda coppia: coppia[1]))  # → {'Marta': 26, 'Lucia': 31, 'Sergio': 38}
sorted(ore, key=ore.get)  # → ['Marta', 'Lucia', 'Sergio']

Il risultato è una lista di tuple: con [:2] tieni i primi due della classifica, con dict(...) torni a un dizionario. Se ti bastano i nomi in ordine, sorted(ore, key=ore.get).

lambda coppia: coppia[1] è una funzione piccola, senza nome: riceve una coppia e restituisce il suo secondo pezzo. La trovi spiegata nella pagina Le funzioni.

La chiave con il valore più alto

max(d, key=d.get): scorre le chiavi, ma per confrontarle chiede al dizionario il valore di ognuna. Con min trovi quella con il valore più basso.

Python
ore = {"Lucia": 31, "Sergio": 38, "Marta": 26}
max(ore, key=ore.get)  # → 'Sergio'
min(ore, key=ore.get)  # → 'Marta'
max(ore.values())  # → 38
max(ore.items(), key=lambda coppia: coppia[1])  # → ('Sergio', 38)

Scrivi ore.get senza tonde: non la chiami tu, la passi a max, che la chiama per ogni chiave. Se ti servono sia il nome sia il numero, usa l'ultima riga: ti dà la coppia intera. A pari merito vince la chiave che viene prima nel dizionario.

Python
ore = {"Lucia": 31, "Ivo": 40}
max(ore)  # → 'Lucia'
max(ore, key=ore.get)  # → 'Ivo'

len()

Quante coppie ci sono nel dizionario, cioè quante chiavi.

Python
vagoni = {"M12": 4, "M14": 3, "M16": 6}
len(vagoni)  # → 3
sum(vagoni.values())  # → 13
len({})  # → 0
bool({})  # → False

len conta le chiavi, non somma i valori: per il totale dei vagoni c'è sum(vagoni.values()). Un dizionario vuoto vale False in un if, quindi if not vagoni: vuol dire «se è vuoto».

Comprehension

Costruisce un dizionario in una riga, come la comprehension delle liste: tra graffe, con chiave: valore davanti al for. Un if in fondo tiene solo alcune coppie.

Python
prezzi = {"urbana": 1.5, "extraurbana": 2.5}
{zona: prezzo * 2 for zona, prezzo in prezzi.items()}  # → {'urbana': 3.0, 'extraurbana': 5.0}

ore = {"Lucia": 31, "Sergio": 38, "Marta": 26}
{nome: h for nome, h in ore.items() if h > 30}  # → {'Lucia': 31, 'Sergio': 38}

fermate = ["Porta Codice", "Via Variabile", "Largo Lista"]
{fermata: len(fermata) for fermata in fermate}  # → {'Porta Codice': 12, 'Via Variabile': 13, 'Largo Lista': 11}

badge = {"B-01": "Lucia", "B-02": "Ivo"}
{nome: codice for codice, nome in badge.items()}  # → {'Lucia': 'B-01', 'Ivo': 'B-02'}

L'ultima riga scambia chiavi e valori: da «chi ha il badge B-01?» a «che badge ha Lucia?». Se due chiavi hanno lo stesso valore, nel dizionario girato ne resta una sola. Se la comprehension ti sembra difficile da leggere, scrivi il for per esteso: fa la stessa cosa.

Una lista di dizionari

È la forma dei dati che arrivano da un'API in JSON: una lista di cose, e ogni cosa è un dizionario con i suoi campi. Si legge da sinistra a destra: prima la posizione nella lista, poi la chiave.

Python
treni = [
    {"codice": "M12", "vagoni": 4, "fermate": ["Porta Codice", "Largo Lista"]},
    {"codice": "M14", "vagoni": 3, "fermate": ["Via Variabile", "Ponte Ciclo"]},
]
len(treni)  # → 2
treni[0]["codice"]  # → 'M12'
treni[1]["fermate"][-1]  # → 'Ponte Ciclo'

for treno in treni:
    print(treno["codice"], treno["vagoni"])
# → M12 4
# → M14 3

[treno["codice"] for treno in treni if treno["vagoni"] > 3]  # → ['M12']

Il JSON ha le stesse parentesi di Python: le quadre diventano una lista, le graffe un dizionario. Il modulo json fa il passaggio:

Python
import json
testo = '[{"codice": "M12", "vagoni": 4}, {"codice": "M14", "vagoni": 3}]'
treni = json.loads(testo)
treni[1]["vagoni"]  # → 3
json.dumps(treni[0])  # → '{"codice": "M12", "vagoni": 4}'

Un dizionario di dizionari

Quando le cose le cerchi per codice, invece di scorrerle tutte: la chiave è il codice, il valore è il dizionario con i campi.

Python
deposito = {
    "M12": {"vagoni": 4, "macchinista": "Lucia"},
    "M14": {"vagoni": 3, "macchinista": "Ivo"},
}
deposito["M14"]["macchinista"]  # → 'Ivo'
deposito["M14"]["vagoni"] = 5
deposito["M14"]  # → {'vagoni': 5, 'macchinista': 'Ivo'}
deposito["M99"]["vagoni"]  # → KeyError: 'M99'

for codice, treno in deposito.items():
    print(codice, "guidato da", treno["macchinista"])
# → M12 guidato da Lucia
# → M14 guidato da Ivo

Da una lista di dizionari a un dizionario di dizionari, con una comprehension: la chiave è un pezzo del valore. Nel capitolo questo schema si chiama indicizzare.

Python
treni = [{"codice": "M12", "vagoni": 4}, {"codice": "M14", "vagoni": 3}]
deposito = {treno["codice"]: treno for treno in treni}
deposito["M14"]  # → {'codice': 'M14', 'vagoni': 3}

copy()

= non copia un dizionario: attacca una seconda etichetta alla stessa scatola. Cambi da una parte, cambia anche dall'altra. copy() fa una scatola nuova.

Python
tempi = {"M12": 30, "M14": 25}
nuovi = tempi
nuovi["M12"] = 35
tempi  # → {'M12': 35, 'M14': 25}

tempi = {"M12": 30, "M14": 25}
copia = tempi.copy()
copia["M12"] = 35
tempi  # → {'M12': 30, 'M14': 25}
copia  # → {'M12': 35, 'M14': 25}

dict(tempi) fa la stessa cosa di tempi.copy(). Usalo quando una funzione deve restituire un dizionario nuovo senza toccare quello che riceve.

Python
gruppi = {"Largo Lista": ["Lucia"]}
copia = gruppi.copy()
copia["Largo Lista"].append("Ivo")
gruppi  # → {'Largo Lista': ['Lucia', 'Ivo']}