Dizionari in

Informazioni su Dizionari

Un dizionario (dict) in Python è una struttura dati che associa chiavi hashable a valori ed è nota in altri linguaggi di programmazione come tabella hash ridimensionabile, hashmap o array associativo. I dizionari sono l'unico tipo di mapping integrato in Python.

Le keys devono essere hashable e uniche all'interno del dizionario. I tipi di chiave possono includere number, str o tuple (di valori immutabili). Non possono contenere strutture dati mutabili come list, dict o set. A partire da Python 3.7, l'ordine delle chiavi di un dict è garantito essere quello in cui le voci vengono inserite.

I values possono essere di qualsiasi tipo o struttura dati. I valori possono anche annidarsi arbitrariamente, quindi possono includere liste di liste, sotto-dizionari e altre strutture dati personalizzate o composte.

Data una key, i dizionari possono recuperare un value in tempo costante (in media, indipendentemente dal numero di voci). Rispetto alla ricerca di un valore all'interno di una list o di un array (senza conoscere la posizione dell'index), un dict usa molta più memoria, ma il recupero è molto rapido.

I dizionari sono particolarmente utili negli scenari in cui la collezione di elementi è grande e deve essere consultata e aggiornata di frequente.

Costruzione di un dizionario

I dizionari possono essere creati in molti modi diversi, tra cui:

• Usare il metodo di classe fromkeys().
• Usare le dictionary comprehensions.
• Unire due dizionari tramite unpacking (**).
• Unire dizionari tramite l'operatore | (update).
• Usare un ciclo per aggiungere iterativamente voci a un dict vuoto creato in precedenza.

I due metodi più diretti sono il costruttore del dizionario e il letterale del dizionario.

Il costruttore del dizionario

dict() (il costruttore della classe dict) può essere usato con qualsiasi iterabile di coppie key, value. Può anche essere chiamato con una serie di argomenti <name>=<value>:

# Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),
...              ('speed', 23),
...              ('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Using key=value arguments.
>>> bear = dict(name="Black Bear",
...             speed=40,
...             land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}

La documentazione sui dict illustra ulteriori varianti e opzioni nell'uso del costruttore.

I letterali di dizionario

Un dizionario può anche essere scritto direttamente come letterale di dizionario, usando le parentesi graffe ({}) che racchiudono coppie key : value. Le voci racchiuse nelle {} possono anche comparire su righe separate:

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

Dizionari annidati

I dizionari possono essere annidati in modo arbitrario:

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

Accedere ai valori in un dict

Puoi accedere a un value in un dizionario usando una key tra parentesi quadre. Se una chiave non esiste nel dizionario, viene sollevato un KeyError:

>>> bear["speed"]
40

>>> bear["color"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'color'

Accedere a una voce tramite il metodo get(<key>, <default value>) può evitare il KeyError:

>>> bear.get("color", 'not found')
'not found'

Accedere alle voci di un dizionario annidato

Per accedere alle voci in dizionari annidati, usa parentesi successive. Se una determinata chiave manca, verrà sollevato il solito KeyError:

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

Per evitare il KeyError, si può usare .get(), ma le chiamate a .get() devono essere concatenate:

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

Modificare o aggiungere valori a un dizionario

Puoi modificare il value di una voce assegnando alla sua key:

# Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}

>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}

Nuove coppie key:value possono essere aggiunte allo stesso modo:

# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}

>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}

Rimuovere voci dal dizionario (pop e del)

Puoi usare il metodo <dict>.pop(<key>) per eliminare una voce dal dizionario. <dict>.pop() rimuove la coppia (key, value) e restituisce il value perché venga usato. Come <dict>.get(), <dict>.pop(<key>) accetta un secondo argomento (<dict>.pop(<key>, <default value>)) che verrà restituito se la key non viene trovata. Questo evita che venga sollevato un KeyError:

# Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'


# The "name" key is now removed from the dictionary.
# Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'


# Using a default argument with .pop() will 
# prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'

Puoi anche usare l'istruzione del per rimuovere una o più voci. Viene sollevato un KeyError se la voce da rimuovere non viene trovata nel dizionario:

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

Scorrere e iterare un dizionario

Scorrere un dizionario con for item in dict o while item itera sulle keys per impostazione predefinita. Puoi accedere ai values all'interno dello stesso ciclo usando le parentesi quadre:

>>> for key in bear:
...     print((key, bear[key])) # <--This prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

Puoi anche usare il metodo .items(), che restituisce tuple (key, value):

# dict.items() forms (key, value tuples) that can be 
# unpacked and iterated over.
>>> for key, value in whale.items():
...     print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1

Allo stesso modo, .keys() restituisce le keys e .values() restituisce i values.

Per una spiegazione dettagliata dei dizionari in Python, la documentazione ufficiale è un ottimo punto di partenza, oppure puoi dare un'occhiata al tutorial di W3-Schools.

Estendere le funzionalità di un dizionario: il modulo collections

Il modulo collections aggiunge funzionalità specializzate ai tipi di dati standard di Python basati su collezioni (dict, set, list, tuple). Tre delle classi basate su dizionari più utili sono:

• Counter conta automaticamente gli elementi e li restituisce in un dict con gli elementi come chiavi e i loro conteggi come valori.
• OrderedDict ha metodi specializzati per disporre l'ordine delle voci del dizionario.
• defaultdict usa un metodo factory per impostare un valore predefinito se una key non viene trovata quando si cerca di recuperare o assegnare una voce del dizionario.