Dizionari in Python: creare, leggere, aggiornare e scorrere un dict

Un dizionario è una tabella di ricerca

Le liste sono indicizzate per posizione. I dizionari sono indicizzati per chiave, di solito una stringa o un numero, e ogni chiave corrisponde a un valore. Questo solo cambiamento apre un'enorme categoria di programmi: inventari, configurazioni, payload JSON, profili utente, cache.

prices = {
    "apple": 0.50,
    "bread": 2.00,
    "milk": 1.20,
}

print(prices["apple"])
print(prices["bread"])

Chiavi e valori possono essere quasi qualsiasi cosa. Le chiavi devono essere hashable (quindi numeri, stringhe, tuple; non liste o altri dict). I valori non hanno restrizioni: un dict può contenere qualsiasi cosa, compresi altri dict o liste.

Creare dizionari

Ci sono diversi modi, ognuno con il suo momento:

# Letterale con le parentesi graffe
user = {"name": "Rosa", "age": 30, "city": "Lisbon"}
print(user)

# Dict vuoto, riempito man mano
counts = {}
counts["a"] = 1
counts["b"] = 2
print(counts)

# Da una lista di coppie (chiave, valore)
pairs = [("one", 1), ("two", 2), ("three", 3)]
mapping = dict(pairs)
print(mapping)

# Con argomenti keyword
config = dict(host="localhost", port=8080, debug=True)
print(config)

Leggere i valori

Due modi, e la scelta conta:

prices = {"apple": 0.50, "bread": 2.00}

# []: accesso diretto. KeyError se manca.
print(prices["apple"])

# .get(): restituisce None (o un valore predefinito) se manca.
print(prices.get("milk"))              # None
print(prices.get("milk", 0.00))        # 0.00

Scegli in base all'intenzione:

• Usa [] quando la chiave deve esserci. Se non c'è, è un bug e vuoi un errore bene in vista.
• Usa .get() quando "non presente" è un caso valido. Ti permette di scrivere valori predefiniti senza try/except.

Aggiungere, aggiornare, cancellare

Assegnare un valore a una chiave la crea o la aggiorna:

prices = {"apple": 0.50, "bread": 2.00}

prices["milk"] = 1.20        # chiave nuova
prices["apple"] = 0.60       # chiave esistente, sovrascritta

print(prices)

del prices["bread"]          # rimuove una chiave; KeyError se manca
print(prices)

gone = prices.pop("apple")   # rimuove e restituisce; accetta un valore predefinito
print("was:", gone, "now:", prices)

# pop con un valore predefinito così non solleva errori
prices.pop("missing", None)

update() unisce un altro dict o un iterabile di coppie:

settings = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

settings.update(overrides)
print(settings)

Le chiavi in comune in overrides sovrascrivono quelle in settings.

Verificare se esiste una chiave

in controlla le chiavi, non i valori:

user = {"name": "Rosa", "age": 30}

print("name" in user)      # True
print("email" in user)     # False
print("Rosa" in user)      # False: quello è un valore, non una chiave

Per controllare proprio i valori, usa user.values():

print(30 in user.values())

Come scorrere un dizionario

Hai tre viste su cui fare un ciclo:

scores = {"ada": 90, "rosa": 85, "malik": 78}

# Chiavi (il comportamento predefinito)
for name in scores:
    print(name)

# Valori
for score in scores.values():
    print(score)

# Entrambi: il caso più comune
for name, score in scores.items():
    print(f"{name}: {score}")

.items() è quello che userai la maggior parte delle volte: ti dà la coppia, già spacchettata e pronta all'uso.

Nel Python moderno (3.7+) l'ordine di iterazione corrisponde all'ordine di inserimento. Un dict non è un "sacco magico": se aggiungi a, poi b, poi c, l'iterazione li restituisce in quell'ordine. È una garanzia del linguaggio su cui puoi contare.

Come ordinare un dizionario

I dizionari conservano l'ordine di inserimento, quindi "ordinare" un dict significa in realtà costruirne uno nuovo le cui chiavi vengono inserite nell'ordine che vuoi:

scores = {"rosa": 85, "ada": 90, "malik": 78}

# Ordina per chiave
by_key = dict(sorted(scores.items()))
print(by_key)

# Ordina per valore (crescente)
by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
print(by_value)

# Ordina per valore, decrescente
top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(top)

sorted() restituisce una lista di coppie; avvolgerla in dict(...) ricostruisce un dizionario con il nuovo ordine. Se ti servono solo le coppie ordinate (non un dict), salta la chiamata esterna a dict().

Come unire due dizionari

Python 3.9+ ti offre l'operatore |:

defaults = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

merged = defaults | overrides
print(merged)

Se una chiave compare in entrambi, vince il valore del dict a destra. .update() è l'equivalente che modifica sul posto. Nelle versioni più vecchie di Python, usa {**defaults, **overrides}.

Lo schema setdefault

Un'esigenza comune: "se la chiave c'è, usa il suo valore; se no, imposta un valore predefinito e poi usalo".

counts = {}

for word in ["one", "two", "one", "three", "two", "one"]:
    counts.setdefault(word, 0)
    counts[word] += 1

print(counts)

Oppure, meglio ancora, usa collections.Counter:

from collections import Counter

words = ["one", "two", "one", "three", "two", "one"]
print(Counter(words))

Counter è una sottoclasse di dict che fa i conteggi in automatico. È la scelta giusta ogni volta che conti delle occorrenze.

Dict comprehension

Come le list comprehension, ma per costruire dict:

numbers = [1, 2, 3, 4, 5]
squares = {n: n * n for n in numbers}
print(squares)

# Inverti un dict (le chiavi diventano valori e viceversa)
prices = {"apple": 0.50, "bread": 2.00}
lookup = {v: k for k, v in prices.items()}
print(lookup)

Stesse regole delle list comprehension, ma con key: value tra le parentesi graffe.

Il dict, gemello del JSON

I dict di Python corrispondono quasi perfettamente agli oggetti JSON. Convertire dall'uno all'altro richiede una sola chiamata:

import json

data = {"name": "Rosa", "age": 30, "tags": ["python", "docs"]}

as_json = json.dumps(data)
print(as_json)

back = json.loads(as_json)
print(back)

Ecco perché i dict compaiono ovunque nello sviluppo web: le tue richieste e risposte API sono in pratica manipolazione di dict con un po' di rete in mezzo.

Un esempio pratico

Un piccolo programma in stile configurazione che gestisce un profilo utente:

user = {
    "name": "Rosa",
    "email": "rosa@example.com",
    "preferences": {
        "theme": "dark",
        "notifications": True,
    },
    "tags": ["python", "docs"],
}

print(user["name"])
print(user["preferences"]["theme"])
print(user.get("last_login", "never"))

user["tags"].append("seo")
user["preferences"]["theme"] = "light"

print(user)

Dict annidati, valori modificabili, .get() con un valore predefinito: la cassetta degli attrezzi di base per qualsiasi dato a forma di record.

Andiamo avanti

Liste, tuple, set, dict. Con queste quattro collezioni in mano puoi modellare quasi tutti i dati che incontrerai all'inizio. Nel prossimo argomento vedremo la list comprehension, il modo compatto di Python per trasformare una collezione in un'altra.