Dizionari

I dizionari (dict) sono un tipo built-in, mutabile e non ordinato che contiene elementi (items) formati da una chiave (key) e un valore (value). Una volta che il dizionario è creato e valorizzato con un insieme di coppie <chiave, valore>, si può usare la chiave (che deve essere univoca) per ottenere il valore corrispondente.

I dizionari sono implementati usando delle tabelle hash che consentono di ottenere il valore corrispondente alla chiave in modo molto efficiente, indipendentemente dal numero di elementi nel dizionario. La maggior parte dei linguaggi contiene una struttura dati simile, anche se chiamata in modo diverso: il tipo hash in Perl, Hashtable in Java o C#, le mappe MFC per Visual C++, gli array associativi in PHP, eccetera.

Definire i dizionari

I dizionari vengono definiti elencando tra parentesi graffe ({}) una serie di elementi separati da virgole (,), dove ogni elemento è formato da una chiave e un valore separati dai due punti (:). È possibile creare un dizionario vuoto usando le parentesi graffe senza nessun elemento all'interno.

>>> d = {'a': 1, 'b': 2, 'c': 3}  # nuovo dizionario di 3 elementi
>>> d
{'c': 3, 'a': 1, 'b': 2}

In questo esempio possiamo vedere che d è un dizionario che contiene 3 elementi formati da una chiave e un valore. 'a', 'b' e 'c' sono le chiavi, mentre 1, 2 e 3 sono i valori. Possiamo anche notare come l'ordine degli elementi sia arbitrario, dato che i dizionari non sono ordinati.

>>> d = {'a': 1}  # dizionario di un elemento
>>> d
{'a': 1}
>>> type(d)  # verifichiamo che il tipo sia "dict"
<class 'dict'>
>>> d = {}  # dizionario vuoto
>>> d
{}

Le chiavi di un dizionario sono solitamente stringhe, ma è possibile usare anche altri tipi, a patto che siano "hashabili" (in genere i tipi immutabili lo sono). I valori possono essere di qualsiasi tipo.

>>> d = {20: ['Jack', 'Jane'], 28: ['John', 'Mary']}  # int come chiavi, list come valori
>>> d
{28: ['John', 'Mary'], 20: ['Jack', 'Jane']}
>>> d = {[0, 10]: 'primo intervallo'}  # le liste non sono hashabili, non sono chiavi valide
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> d = {(0, 10): 'primo intervallo'}  # le tuple sì
>>> d
{(0, 10): 'primo intervallo'}

Usare i dizionari

Una volta creato un dizionario, è possibile ottenere il valore associato a una chiave usando la sintassi dizionario[chiave]:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> d['a']  # ritorna il valore associato alla chiave 'a'
1
>>> d['c']  # ritorna il valore associato alla chiave 'c'
3

Se viene specificata una chiave inesistente, Python restituisce un KeyError. È però possibile usare l'operatore in (o not in) per verificare se una chiave è presente nel dizionario:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> d['x']  # se la chiave non esiste restituisce un KeyError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'x'
>>> 'x' in d  # la chiave 'x' non è presente in d
False
>>> 'x' not in d  # la chiave 'x' non è presente in d
True
>>> 'b' in d  # la chiave 'b' è presente
True
>>> d['b']  # il valore associato alla chiave 'b' è 2
2

È possibile aggiungere o modificare elementi usando la sintassi dizionario[chiave] = valore e rimuoverli usando la sintassi del dizionario[chiave]:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> d['a'] = 10  # modifica il valore associato a una chiave esistente
>>> d
{'c': 3, 'a': 10, 'b': 2}
>>> d['x'] = 123  # crea un nuovo elemento, con chiave 'x' e valore 123
>>> d
{'x': 123, 'c': 3, 'a': 10, 'b': 2}
>>> del d['x']  # rimuove l'elemento (chiave e valore) con chiave 'x'
>>> d
{'c': 3, 'a': 10, 'b': 2}

I dizionari supportano anche diversi metodi:

Metodo	Descrizione
d.items()	Restituisce gli elementi di d come un insieme di tuple
d.keys()	Restituisce le chiavi di d
d.values()	Restituisce i valori di d
d.get(chiave, default)	Restituisce il valore corrispondente a chiave se presente, altrimenti il valore di default (None se non specificato)
d.pop(chiave, default)	Rimuove e restituisce il valore corrispondente a chiave se presente, altrimenti il valore di default (dà KeyError se non specificato)
d.popitem()	Rimuove e restituisce un elemento arbitrario da d
d.update(d2)	Aggiunge gli elementi del dizionario d2 a quelli di d
d.copy()	Crea e restituisce una copia di d
d.clear()	Rimuove tutti gli elementi di d

>>> d = {'a': 1, 'b': 2, 'c': 3}  # nuovo dict di 3 elementi
>>> len(d)  # verifica che siano 3
3
>>> d.items()  # restituisce gli elementi
dict_items([('c', 3), ('a', 1), ('b', 2)])
>>> d.keys()  # restituisce le chiavi
dict_keys(['c', 'a', 'b'])
>>> d.values()  # restituisce i valori
dict_values([3, 1, 2])
>>> d.get('c', 0)  # restituisce il valore corrispondente a 'c'
3
>>> d.get('x', 0)  # restituisce il default 0 perché 'x' non è presente
0
>>> d  # il dizionario contiene ancora tutti gli elementi
{'c': 3, 'a': 1, 'b': 2}
>>> d.pop('a', 0)  # restituisce e rimuove il valore corrispondente ad 'a'
1
>>> d.pop('x', 0)  # restituisce il default 0 perché 'x' non è presente
0
>>> d  # l'elemento con chiave 'a' è stato rimosso
{'c': 3, 'b': 2}
>>> d.pop('x')  # senza default e con chiave inesistente dà errore
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'x'
>>> d.popitem()  # restituisce e rimuove un elemento arbitrario
('c', 3)
>>> d  # l'elemento con chiave 'c' è stato rimosso
{'b': 2}
>>> d.update({'a': 1, 'c': 3})  # aggiunge di nuovo gli elementi 'a' e 'c'
>>> d
{'c': 3, 'a': 1, 'b': 2}
>>> d.clear()  # rimuove tutti gli elementi
>>> d  # lasciando un dizionario vuoto
{}

Esistono anche altri metodi che vengono usati più raramente, e che possono essere visualizzati usando dir(dict) e help(dict.metodo) o consultando la documentazione ufficiale sui dizionari.

Nella prossima lezione vedremo un altro tipo di dato built-in: i set.