Python Language
Dizionario

Sintassi

• mydict = {}
• mydict [k] = valore
• value = mydict [k]
• valore = mydict.get (k)
• value = mydict.get (k, "valore_predefinito")

Parametri

Osservazioni

Accesso ai valori di un dizionario

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

Il codice precedente stamperà 1234 .

La stringa "Hello" in questo esempio è chiamata chiave . È usato per cercare un valore nel dict posizionando la chiave tra parentesi quadre.

Il numero 1234 è visto dopo i rispettivi due punti nella definizione del dict . Questo è chiamato il valore che "Hello" mappe al presente dict .

La ricerca di un valore come questo con una chiave che non esiste solleverà un'eccezione KeyError , interrompendo l'esecuzione se non KeyError . Se vogliamo accedere a un valore senza rischiare un KeyError , possiamo usare il metodo dictionary.get . Per impostazione predefinita, se la chiave non esiste, il metodo restituirà None . Possiamo passargli un secondo valore da restituire invece di None in caso di una ricerca fallita.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

In questo esempio w otterrà il valore None e x otterrà il valore "nuh-uh" .

Il costruttore dict ()

Il costruttore dict() può essere usato per creare dizionari da argomenti di parole chiave, o da un singolo iterabile di coppie chiave-valore, o da un singolo dizionario e argomenti di parole chiave.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

Evitare Eccezioni KeyError

Un errore comune quando si utilizzano i dizionari è di accedere a una chiave inesistente. Ciò in genere KeyError un'eccezione KeyError

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

Un modo per evitare errori chiave consiste nell'utilizzare il metodo dict.get , che consente di specificare un valore predefinito da restituire nel caso di una chiave assente.

value = mydict.get(key, default_value)

Che restituisce mydict[key] se esiste, ma restituisce altrimenti default_value . Nota che questo non aggiunge la key a mydict . Quindi, se si desidera mantenere quella coppia chiave-valore, si dovrebbe utilizzare mydict.setdefault(key, default_value) , che non memorizzare la coppia chiave-valore.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

Un modo alternativo per affrontare il problema è l'eccezione

try:
    value = mydict[key]
except KeyError:
    value = default_value

Puoi anche controllare se la chiave è in dizionario.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

Si noti, tuttavia, che negli ambienti a più thread è possibile che la chiave venga rimossa dal dizionario dopo il controllo, creando una condizione di competizione in cui è ancora possibile lanciare l'eccezione.

Un'altra opzione è usare una sottoclasse di dict, collections.defaultdict, che ha un default_factory per creare nuove voci nel dict quando viene dato un new_key.

Accesso a chiavi e valori

Quando si lavora con i dizionari, è spesso necessario accedere a tutte le chiavi e i valori del dizionario, in un ciclo for , in una list comprehension o semplicemente come un elenco semplice.

Dato un dizionario come:

mydict = {
    'a': '1',
    'b': '2'
}

Puoi ottenere un elenco di chiavi usando il metodo keys() :

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

Se invece vuoi un elenco di valori, usa il metodo values() :

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

Se vuoi lavorare sia con la chiave che con il suo valore corrispondente, puoi usare il metodo items() :

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

NOTA: poiché un dict non è ordinato, le keys() , values() e items() non hanno alcun ordinamento. Utilizzare sort() , sorted() , o un OrderedDict se vi preoccupate per l'ordine che questi metodi restituiscono.

Python 2/3 Differenza: In Python 3, questi metodi restituiscono oggetti iterabili speciali, non elenchi e sono l'equivalente dei iterkeys() , itervalues() e iteritems() di Python 2. Questi oggetti possono essere utilizzati come liste per la maggior parte, anche se ci sono alcune differenze. Vedi PEP 3106 per maggiori dettagli.

Introduzione al dizionario

Un dizionario è un esempio di un archivio di valori chiave noto anche come Mapping in Python. Permette di memorizzare e recuperare elementi facendo riferimento a una chiave. Poiché i dizionari fanno riferimento alla chiave, hanno una ricerca molto veloce. Poiché vengono principalmente utilizzati per referenziare gli elementi per chiave, non vengono ordinati.

creando un ditt

I dizionari possono essere avviati in molti modi:

sintassi letterale

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

Detto comprensione

d = {k:v for k,v in [('key', 'value',)]}

vedi anche: Comprensioni

classe built-in: dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

modificare un dett

Per aggiungere elementi a un dizionario, è sufficiente creare una nuova chiave con un valore:

d['newkey'] = 42

È anche possibile aggiungere list e dictionary come valore:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

Per eliminare un elemento, elimina la chiave dal dizionario:

del d['newkey']

Dizionario con valori predefiniti

Disponibile nella libreria standard come defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] In alternativa, se devi utilizzare la classe dict incorporata, l' using dict.setdefault() ti consente di creare un valore predefinito ogni volta che accedi a una chiave che non esisteva prima:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

Tieni presente che se hai molti valori da aggiungere, dict.setdefault() creerà una nuova istanza del valore iniziale (in questo esempio a [] ) ogni volta che viene chiamato, il che potrebbe creare carichi di lavoro non necessari.

[*] Python Cookbook, 3a edizione, di David Beazley e Brian K. Jones (O'Reilly). Copyright 2013 David Beazley e Brian Jones, 978-1-449-34037-7.

Creare un dizionario ordinato

È possibile creare un dizionario ordinato che seguirà un determinato ordine durante l'iterazione sui tasti del dizionario.

Usa OrderedDict dal modulo delle collections . Ciò restituirà sempre gli elementi del dizionario nell'ordine di inserimento originale quando viene ripetuto.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

Disimballaggio dei dizionari usando l'operatore **

È possibile utilizzare l'operatore di disimballaggio dell'argomento parola chiave ** per distribuire le coppie chiave-valore in un dizionario negli argomenti di una funzione. Un esempio semplificato dalla documentazione ufficiale :

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

A partire da Python 3.5 è anche possibile utilizzare questa sintassi per unire un numero arbitrario di oggetti dict .

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Come dimostra questo esempio, le chiavi duplicate si associano al loro ultimo valore (ad esempio "Clifford" sovrascrive "Nemo").

Unione di dizionari

Considera i seguenti dizionari:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Come dimostra questo esempio, le chiavi duplicate si associano al loro ultimo valore (ad esempio "Clifford" sovrascrive "Nemo").

Python 3.3+

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

Con questa tecnica il valore più importante ha la precedenza per un dato tasto piuttosto che per l'ultimo ("Clifford" viene buttato in favore di "Nemo").

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Questo usa il valore ultimo, come con la tecnica basata su ** per l'unione ("Clifford" sovrascrive "Nemo").

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update usa il secondo dict per sovrascrivere quello precedente.

La virgola finale

Come gli elenchi e le tuple, puoi includere una virgola finale nel dizionario.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8 indica che è necessario lasciare uno spazio tra la virgola finale e quella di chiusura.

Tutte le combinazioni di valori del dizionario

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

Dato un dizionario come quello mostrato sopra, dove c'è una lista che rappresenta un insieme di valori da esplorare per la chiave corrispondente. Supponiamo di voler esplorare "x"="a" con "y"=10 , quindi "x"="a" con "y"=10 e così via fino a quando non hai esplorato tutte le possibili combinazioni.

Puoi creare una lista che restituisca tutte queste combinazioni di valori usando il seguente codice.

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

Questo ci dà il seguente elenco memorizzato nelle combinations variabili:

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

Iterare su un dizionario

Se si utilizza un dizionario come iteratore (ad esempio in una dichiarazione for ), attraversa le chiavi del dizionario. Per esempio:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

Lo stesso è vero quando usato in una comprensione

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

Creare un dizionario

Regole per creare un dizionario:

• Ogni chiave deve essere unica (altrimenti verrà ignorata)
• Ogni chiave deve essere hashable (può utilizzare la hash funzione di hash che, altrimenti TypeError sarà gettato)
• Non c'è un ordine particolare per le chiavi.

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

Esempio di dizionari

I dizionari mappano le chiavi ai valori.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

I valori del dizionario sono accessibili tramite le loro chiavi.

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

I dizionari possono anche essere creati in uno stile JSON:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

I valori del dizionario possono essere ripetuti su:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette