Metodi dei Dizionari Python

I dizionari Python memorizzano i dati come coppie chiave-valore e dispongono di un ricco insieme di metodi integrati per leggere, aggiungere, aggiornare e rimuovere elementi. Questo capitolo tratta tutti i metodi dei dizionari disponibili in Python 3, con esempi corretti e note pratiche su quando — e quando non — usare ciascuno di essi.

Per un'introduzione generale ai dizionari (creazione, accesso agli elementi, annidamento), consulta il capitolo Dizionari Python.

Cos'è un Dizionario Python?

Un dizionario associa chiavi univoche a valori. Le chiavi devono essere hashable (string, numeri e tuple di elementi hashable funzionano; le liste no). I valori possono essere qualsiasi oggetto Python.

person = {"name": "Alice", "age": 28, "city": "Berlin"}

I dizionari mantengono l'ordine di inserimento a partire da Python 3.7 — l'iterazione restituisce sempre le chiavi nell'ordine in cui sono state aggiunte.

Metodi dei Dizionari in Sintesi

clear()

clear() rimuove ogni elemento dal dizionario in place, lasciando un dizionario vuoto. Usalo quando hai bisogno di riutilizzare lo stesso oggetto dizionario anziché crearne uno nuovo.

Attenzione: inventory = {} sembra simile ma crea un nuovo oggetto dizionario. Se un'altra variabile punta allo stesso dizionario, clear() lo svuota per entrambe; la riassegnazione invece no.

a = {"x": 1}
b = a
a.clear()
print(b)   # Output: {}  — b sees the change

a = {"x": 1}
b = a
a = {}
print(b)   # Output: {'x': 1}  — b is unaffected

copy()

copy() restituisce una copia superficiale — un nuovo dizionario con le stesse chiavi e riferimenti agli stessi valori.

Attenzione: se un valore è un oggetto mutabile (lista, dizionario, set), sia l'originale sia la copia condividono quell'oggetto. Usa copy.deepcopy() quando hai bisogno di una piena indipendenza.

Per ulteriori dettagli su come copiare i dizionari in modo sicuro, consulta Copiare i Dizionari.

fromkeys()

fromkeys(iterable, value) è un metodo di classe che costruisce un nuovo dizionario da una sequenza di chiavi, tutte mappate allo stesso valore (default None).

fields = ["name", "email", "phone"]
record = dict.fromkeys(fields, "")
print(record)
# Output: {'name': '', 'email': '', 'phone': ''}

Attenzione: se il valore predefinito è mutabile (es. una lista), tutte le chiavi condividono lo stesso oggetto:

bad = dict.fromkeys(["a", "b"], [])
bad["a"].append(1)
print(bad)  # Output: {'a': [1], 'b': [1]}  — both share the list!

La soluzione è usare una dict comprehension:

good = {k: [] for k in ["a", "b"]}
good["a"].append(1)
print(good)  # Output: {'a': [1], 'b': []}

get()

get(key, default=None) restituisce il valore per key se esiste, altrimenti default. Non solleva mai KeyError.

Quando usarlo: preferisci get() a dict[key] quando la chiave potrebbe essere assente. Usa la forma a due argomenti per fornire un valore predefinito significativo anziché intercettare KeyError in un blocco try/except.

items()

items() restituisce una vista dict_items — un iterabile di tuple (key, value) che riflette lo stato corrente del dizionario.

L'uso più comune è decomporre chiave e valore in un ciclo for:

scores = {"math": 90, "english": 85, "science": 92}
for subject, grade in scores.items():
    print(f"{subject}: {grade}")
# Output:
# math: 90
# english: 85
# science: 92

Le viste sono live — riflettono le modifiche al dizionario senza dover essere rigenerate.

Per ulteriori pattern di iterazione, consulta Iterare i Dizionari.

keys()

keys() restituisce una vista dict_keys di tutte le chiavi nell'ordine di inserimento.

Poiché è una vista, puoi usarla nelle operazioni sugli insiemi per confrontare due dizionari:

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

print(a.keys() & b.keys())  # Output: {'y'}    — keys in both
print(a.keys() | b.keys())  # Output: {'x', 'y', 'z'}  — all keys
print(a.keys() - b.keys())  # Output: {'x'}    — keys only in a

values()

values() restituisce una vista dict_values di tutti i valori.

Casi d'uso comuni:

prices = {"apple": 0.99, "banana": 0.59, "cherry": 2.49}

total = sum(prices.values())
print(f"Total: {total:.2f}")   # Output: Total: 4.07

most_expensive = max(prices.values())
print(most_expensive)          # Output: 2.49

A differenza di keys(), values() non supporta le operazioni sugli insiemi perché i valori non sono garantiti essere univoci.

pop()

pop(key, default) rimuove l'elemento con la chiave specificata e restituisce il suo valore. Se la chiave è assente e non viene fornito un default, solleva KeyError.

Quando usarlo: pop() è lo strumento giusto quando hai bisogno sia di rimuovere un elemento sia di usare il suo valore nella stessa operazione, come nell'elaborazione di elementi da un dizionario simile a una coda.

popitem()

popitem() rimuove e restituisce l'ultima coppia chiave-valore inserita come tupla (key, value). Chiamarlo su un dizionario vuoto solleva KeyError.

data = {"a": 1, "b": 2, "c": 3}

last = data.popitem()
print(last)   # Output: ('c', 3)
print(data)   # Output: {'a': 1, 'b': 2}

Un pattern pratico è elaborare un dizionario in modo distruttivo fino a svuotarlo:

tasks = {"write tests": True, "review PR": False, "deploy": True}
while tasks:
    name, done = tasks.popitem()
    status = "done" if done else "pending"
    print(f"{name}: {status}")

setdefault()

setdefault(key, default=None) restituisce il valore per key se esiste. Se key è assente, lo inserisce con default e restituisce default.

options = {"color": "blue"}

# Key exists — returns existing value, does NOT overwrite
print(options.setdefault("color", "red"))   # Output: blue

# Key absent — inserts and returns default
print(options.setdefault("size", "medium")) # Output: medium

print(options)
# Output: {'color': 'blue', 'size': 'medium'}

Caso d'uso principale: costruire dizionari di liste (raggruppamento):

words = ["apple", "avocado", "banana", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)

print(grouped)
# Output: {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

Questo è più pulito rispetto a un controllo if key not in d: d[key] = [] ad ogni iterazione.

update()

update(other) unisce other nel dizionario, sovrascrivendo le chiavi esistenti. other può essere un altro dizionario, un iterabile di coppie (key, value) oppure argomenti keyword.

Alternativa Python 3.9+: l'operatore |= di unione in place fa la stessa cosa in modo più conciso:

profile = {"name": "Alice", "age": 28}
profile |= {"age": 29, "city": "Berlin"}
print(profile)
# Output: {'name': 'Alice', 'age': 29, 'city': 'Berlin'}

L'operatore | (senza =) restituisce un nuovo dizionario anziché modificare in place.

Accesso e Modifica degli Elementi

Oltre ai metodi sopra descritti, Python fornisce una sintassi diretta per leggere, aggiungere e rimuovere elementi dai dizionari.

Leggere un valore tramite chiave:

Accedere a una chiave inesistente solleva KeyError. Usa get() per evitarlo.

Aggiungere o sovrascrivere un valore:

person = {"name": "Alice", "age": 28}
person["occupation"] = "Engineer"  # new key
person["age"] = 29                 # overwrite existing key
print(person)
# Output: {'name': 'Alice', 'age': 29, 'occupation': 'Engineer'}

Iterare chiavi e valori:

Scegliere il Metodo Giusto

Capitoli Correlati

• Dizionari Python — fondamentali: creazione, accesso e verifica della presenza
• Dizionari Annidati — dizionari di dizionari per dati gerarchici
• Iterare i Dizionari — tutti i pattern di iterazione con keys(), values() e items()
• Copiare i Dizionari — copia superficiale vs. profonda in dettaglio
• Metodi delle Liste — il riferimento equivalente per le liste Python

Esercitazione