Un dizionario (dict) in Python è una struttura dati che associa chiavi hashable a valori ed è conosciuto in altri linguaggi di programmazione come tabella hash ridimensionabile, hashmap o array associativo.
I dizionari sono l'unico tipo di mapping integrato di Python.
Le Keys devono essere hashable e uniche all'interno del dizionario.
I tipi delle chiavi possono includere numbers, str o tuples (di valori immutabili).
Non possono contenere strutture dati mutabili come lists, dicts o sets.
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 in modo arbitrario, 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 (in media) costante (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 l'insieme di elementi è grande e deve essere consultato e aggiornato spesso.
I dizionari possono essere creati in molti modi.
I due più diretti sono usare il costruttore dict() oppure dichiarare un letterale dict.
dict()
dict() (il costruttore della classe dizionario) può essere usato con qualsiasi iterabile di coppie key, value oppure 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}
Un dict può anche essere inserito direttamente come letterale di dizionario, usando parentesi graffe ({}) che racchiudono coppie key : value:
>>> whale = {"name": "Blue Whale", "speed": 35, "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}
Puoi accedere a una voce di un dizionario usando una chiave tra parentesi quadre ([]).
Se una key non esiste nel dict, viene sollevata una 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 la KeyError:
>>> bear.get("color", 'not found')
'not found'
Puoi cambiare il value di una voce assegnandolo alla sua chiave:
#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}
Puoi usare il metodo .pop(<key>) per eliminare una voce di un dizionario.
.pop() rimuove la coppia (key, value) e restituisce il value perché venga usato.
Come .get(), .pop(<key>) accetta un secondo argomento (dict.pop(<key>, <default value>)) che sarà restituito se la key non viene trovata.
Questo evita che venga sollevata una 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'
Iterare su un dizionario con for item in dict o while item esamina per impostazione predefinita solo le chiavi.
Puoi accedere ai valori nello stesso ciclo usando le parentesi quadre:
>>> for key in bear:
>>> print((key, bear[key])) #this forms a tuple of (key, value) and prints it.
('name', 'Black Bear')
('speed', 40)
('land_animal', True)
Puoi anche usare il metodo .items(), che restituisce automaticamente 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, il metodo .keys() restituirà le keys e il metodo .values() restituirà i values.
In questo esercizio gestirai un sistema di inventario.
L'inventario dovrebbe essere organizzato in base al nome degli elementi e tenere traccia del numero di elementi disponibili.
Dovrai occuparti di aggiungere elementi a un inventario.
Ogni volta che un elemento compare in un array dato, la sua quantità nell'inventario dovrebbe aumentare di 1.
Dovrai anche occuparti di eliminare elementi da un inventario diminuendo le quantità di 1 quando richiesto.
Infine, dovrai implementare una funzione che restituisca tutte le coppie chiave-valore di un inventario dato come list di tuples.
Implementa la funzione create_inventory(<input list>) che crea un «inventario» a partire da un array di elementi in input.
Dovrebbe restituire un dict che associa a ogni nome di elemento la rispettiva quantità.
>>> create_inventory(["coal", "wood", "wood", "diamond", "diamond", "diamond"])
{"coal":1, "wood":2, "diamond":3}
Implementa la funzione add_items(<inventory dict>, <item list>) che aggiunge un array di elementi all'inventario passato:
>>> add_items({"coal":1}, ["wood", "iron", "coal", "wood"])
{"coal":2, "wood":2, "iron":1}
Implementa la funzione decrement_items(<inventory dict>, <items list>) che riceve una list di elementi.
La funzione dovrebbe sottrarre 1 al conteggio di un elemento ogni volta che quell'elemento compare nella list:
>>> decrement_items({"coal":3, "diamond":1, "iron":5}, ["diamond", "coal", "iron", "iron"])
{"coal":2, "diamond":0, "iron":3}
I conteggi degli elementi nell'inventario non dovrebbero mai scendere sotto 0.
Se il numero di volte in cui un elemento compare nella list di input supera la quantità disponibile, la quantità indicata per quell'elemento dovrebbe restare a 0.
Le ulteriori richieste di rimozione vanno ignorate una volta che il conteggio arriva a zero.
>>> decrement_items({"coal":2, "wood":1, "diamond":2}, ["coal", "coal", "wood", "wood", "diamond"])
{"coal":0, "wood":0, "diamond":1}
Implementa la funzione remove_item(<inventory dict>, <item>) che rimuove completamente un elemento ed il suo conteggio da un inventario:
>>> remove_item({"coal":2, "wood":1, "diamond":2}, "coal")
{"wood":1, "diamond":2}
Se l'elemento non si trova nell'inventario, la funzione dovrebbe restituire l'inventario originale invariato.
>>> remove_item({"coal":2, "wood":1, "diamond":2}, "gold")
{"coal":2, "wood":1, "diamond":2}
Implementa la funzione list_inventory(<inventory dict>) che riceve un inventario e restituisce un array di tuple (item, quantity).
L'array dovrebbe includere solo gli elementi disponibili (con una quantità maggiore di zero):
>>> list_inventory({"coal":7, "wood":11, "diamond":2, "iron":7, "silver":0})
[('coal', 7), ('diamond', 2), ('iron', 7), ('wood', 11)]
Iscriviti a Exercism per imparare e padroneggiare Python con 17 concetti146 esercizi e il mentoring di persone reali, tutto gratis.