Dictionary comprehension in Python: tutto ciò che devi sapere

Che cos'è un dizionario Python?

Un dizionario in Python è una raccolta di elementi a cui si accede tramite una chiave specifica invece che tramite un indice. Cosa significa?

Immagina un dizionario nel mondo reale. Quando vuoi cercare il significato di una parola, provi a trovarlo usando la parola stessa e non un ipotetico indice della parola. I dizionari Python funzionano con lo stesso concetto: la parola di cui cerchi il significato è la chiave, e il significato della parola è il valore. Non devi conoscere l'indice della parola in un dizionario per trovarne il significato.

Inizializzare un dizionario in Python

Puoi inizializzare un dizionario in Python in questo modo:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])

fruit

print(a[0])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

Per prima cosa, creiamo un dizionario chiamato a che ha tre coppie chiave-valore: 'apple': 'fruit', 'beetroot': 'vegetable' e 'cake': 'dessert'. Le chiavi sono stringhe che rappresentano i nomi degli elementi e i valori sono stringhe che rappresentano il tipo o la categoria dell'elemento.

Poi aggiungiamo una nuova coppia chiave-valore al dizionario a usando la sintassi a ['doughnut'] = 'snack'. Questo aggiunge la chiave 'doughnut' al dizionario con il valore corrispondente 'snack'.

La terza riga del codice stampa il valore associato alla chiave 'apple' nel dizionario a. Poiché 'apple' è una chiave presente nel dizionario, il codice stampa il valore 'fruit'.

La quarta riga del codice prova a stampare il valore associato alla chiave 0 nel dizionario a, che non è una chiave valida del dizionario. Questo genera un KeyError, che viene sollevato quando si tenta di accedere a una chiave che non esiste in un dizionario.

Tipi di dati nei dizionari Python

Gli elementi in un dizionario possono avere qualsiasi tipo di dato. Dai un'occhiata ad altri esempi di dizionario qui sotto per prenderci la mano:

Crea un dizionario a con quattro coppie chiave-valore:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)

Aggiorna il valore associato alla chiave 'one' nel dizionario a a 1.0.

# Update a dictionary
a['one'] = 1.0 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}

Elimina la coppia chiave-valore associata alla chiave 'one' dal dizionario a.

# Delete a single element
del a['one'] 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}

Rimuovi tutte le coppie chiave-valore dal dizionario a usando il metodo clear().

# Delete all elements in the dictionary
a.clear()
print(a)

{}

Elimina il dizionario a usando la parola chiave del.

# Delete the dictionary
del a 
print(a)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined

È importante ricordare che una chiave deve essere univoca in un dizionario; non sono ammessi duplicati. Tuttavia, in caso di chiavi duplicate, invece di dare un errore, Python considererà valida l'ultima istanza della chiave e ignorerà semplicemente la prima coppia chiave-valore. Guarda tu stesso:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])

icecream

Dictionary comprehension in Python

La dictionary comprehension è un metodo per trasformare un dizionario in un altro dizionario. Durante questa trasformazione, gli elementi del dizionario originale possono essere inclusi condizionalmente nel nuovo dizionario e ogni elemento può essere trasformato secondo necessità.

Una buona list comprehension può rendere il tuo codice più espressivo e quindi più facile da leggere. La chiave per creare comprehension è non lasciarle diventare così complesse da farti girare la testa quando provi a decifrare cosa stiano effettivamente facendo. Manteniamo vivo il principio della "facilità di lettura".

Il modo per fare dictionary comprehension in Python è poter accedere agli oggetti key e agli oggetti value di un dizionario.

Come si può fare?

Python ti viene in aiuto! Puoi semplicemente usare i metodi incorporati per fare questo:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()

dict_keys(['c', 'd', 'a', 'b'])

# Put all values saved in `dict1` in a list and returns the list
dict1.values()

dict_values([3, 4, 1, 2])

Il codice sopra crea un dizionario Python chiamato dict1 con quattro coppie chiave-valore. Il metodo keys() viene chiamato sul dizionario e restituisce un oggetto vista che contiene tutte le chiavi del dizionario.

Viene chiamato anche il metodo values() sul dizionario, che restituisce un oggetto vista contenente tutti i valori del dizionario.

Entrambi gli oggetti vista si comportano come insiemi e possono essere usati per eseguire operazioni insiemistiche rispettivamente su chiavi e valori.

Nota che l'ordine delle chiavi e dei valori negli oggetti vista non è garantito che sia lo stesso con cui sono stati aggiunti al dizionario.

Trasformazione di base dei valori 

Iniziamo con una semplice dictionary comprehension:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}

Nel codice di comprehension sopra, creiamo un nuovo dizionario double_dict1 a partire da un dizionario dict1 semplicemente raddoppiandone ciascun valore.

Puoi anche apportare modifiche alle chiavi. Per esempio, creiamo lo stesso dizionario di prima ma cambiando anche i nomi delle chiavi.

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}

Usare il metodo items()

Ora che sai come accedere a tutte le chiavi e ai loro valori in un dizionario, puoi anche accedere a ciascuna coppia chiave-valore in un dizionario usando il metodo items():

dict1.items()

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])

Questo è il modello generale che puoi seguire per la dictionary comprehension in Python:

dict_variable = {key:value for (key,value) in dictonary.items()}

Questo può fungere da modello base e più semplice. Può diventare via via più complesso man mano che aggiungi condizioni.

Usare il metodo fromkeys()

Python offre anche il metodo fromkeys(), che ti permette di creare dizionari con un valore uniforme per un insieme specificato di chiavi. Questo metodo è utile per inizializzare dizionari con valori predefiniti. Guarda qui:

# Create a dictionary with keys ranging from 0 to 4, all set to True
my_dict = dict.fromkeys(range(5), True)
print(my_dict)

{0: True, 1: True, 2: True, 3: True, 4: True}

In questo esempio, il metodo fromkeys() crea un dizionario in cui le chiavi sono i numeri da 0 a 4, e a ogni chiave è assegnato il valore True. Questo approccio semplifica attività come l'inizializzazione di dizionari per successivi aggiornamenti o elaborazioni.

Perché usare la dictionary comprehension?

La dictionary comprehension è un concetto potente e può essere usata al posto dei for loop e delle funzioni lambda. Tuttavia, non tutti i for loop possono essere scritti come dictionary comprehension, mentre tutte le dictionary comprehension possono essere riscritte con un for loop.

Considera il seguente problema in cui vuoi creare un nuovo dizionario in cui la chiave è un numero divisibile per 2 nell'intervallo 0-10 e il suo valore è il quadrato del numero.

Vediamo come puoi risolvere lo stesso problema usando un for loop e una dictionary comprehension:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

Alternativa ai for loop

I for loop si usano per ripetere una certa operazione o un blocco di istruzioni in un programma per un determinato numero di volte. Tuttavia, i for loop annidati (un for loop dentro un altro for loop) possono diventare confusi e complessi. Le dictionary comprehension sono migliori in queste situazioni e possono semplificare la leggibilità e la comprensione del codice.

Consiglio: dai un'occhiata al tutorial di DataCamp Cicli in Python per ulteriori informazioni sui loop in Python.

Alternativa alle funzioni lambda

Le funzioni lambda sono un modo per creare piccole funzioni anonime. Sono funzioni senza nome. Sono funzioni "usa e getta", necessarie solo dove sono state create. Le funzioni lambda sono usate principalmente in combinazione con le funzioni filter(), map() e reduce().

Vediamo la funzione lambda insieme alla funzione map():

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Esempio dettagliato di dictionary comprehension in Python

Vediamo un'altra situazione in cui vuoi convertire un dizionario di temperature in Fahrenheit in Celsius.

Scomponiamo il codice: per prima cosa, devi definire una formula matematica che esegua la conversione da Fahrenheit a Celsius.

Nel codice, ciò viene fatto con l'aiuto della funzione lambda. Passi poi questa funzione come argomento alla funzione map(), che applica l'operazione a ogni elemento della lista fahrenheit.values().

Ricordi la funzione values()? Restituisce una lista contenente gli elementi memorizzati nel dizionario.

Ora hai una lista contenente i valori di temperatura in gradi Celsius, ma la soluzione richiede che sia un dizionario.

Python ha una funzione incorporata chiamata zip() che percorre gli elementi degli iteratori e li aggrega. Puoi leggere di più sulla funzione zip() in questo esempio Python.

Nel nostro esempio sopra, la funzione zip aggrega gli elementi di fahrenheit.keys() e della lista celsius, producendo coppie chiave-valore che puoi assemblare in un dizionario usando la funzione dict, che è il risultato desiderato.

Ora, proviamo a risolvere lo stesso problema usando la dictionary comprehension:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Ecco una spiegazione di ciò che abbiamo creato nel codice sopra: 

1. Crea un dizionario chiamato fahrenheit con quattro coppie chiave-valore che rappresentano rilevazioni di temperatura in Fahrenheit.

2. Definisci un nuovo dizionario chiamato celsius.

3. Usa una dictionary comprehension per iterare sul dizionario fahrenheit e convertire le temperature in Fahrenheit in Celsius usando la formula (5/9) * (F-32).

4. Per ogni coppia chiave-valore in fahrenheit, la chiave viene assegnata alla variabile k e il valore alla variabile v.

5. Il valore della temperatura in Celsius corrispondente a ciascuna temperatura in Fahrenheit viene calcolato usando la formula sopra e aggiunto come coppia chiave-valore al dizionario celsius.

6. Il dizionario celsius risultante viene stampato in console.

Come vedi, il problema può essere risolto con una singola riga di codice usando la dictionary comprehension, rispetto al processo in due passaggi e alla comprensione del funzionamento di tre funzioni (lambda, map() e zip()) della prima implementazione.

Inoltre, la soluzione è intuitiva e facile da capire con la dictionary comprehension. Quindi, la dictionary comprehension può essere una valida alternativa alle funzioni lambda.

Aggiungere condizioni alla dictionary comprehension

Spesso, quando affronti problemi, hai bisogno di aggiungere condizioni a una soluzione. Vediamo come puoi aggiungere condizioni nelle dictionary comprehension per renderle più potenti.

Condizione if

Supponiamo che tu debba creare un nuovo dizionario da uno dato, ma solo con gli elementi che sono maggiori di 2. Questo significa che devi aggiungere una condizione al modello originale che hai visto sopra...

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)

{'e': 5, 'c': 3, 'd': 4}

Non è così difficile! Ma se avessi più condizioni?

Più condizioni if

Nel problema sopra, e se non solo dovessi prendere gli elementi maggiori di 2, ma anche verificare allo stesso tempo se sono multipli di 2?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)

{'d': 4}

La soluzione per aggiungere più condizioni è semplice come mettere le condizioni una dopo l'altra nella tua comprehension. Tuttavia, devi fare attenzione a ciò che stai cercando di fare nel problema. Ricorda che gli if consecutivi funzionano come se tra loro ci fossero clausole and.

Vediamo un altro esempio con tre condizioni:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)

{'f': 6}

In un for loop, questo corrisponderebbe a:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)

{'f': 6}

Condizioni if-else

Gestire una condizione if-else è altrettanto semplice con la dictionary comprehension. Dai un'occhiata al seguente esempio per verificarlo di persona:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}

Dictionary comprehension annidata

L'annidamento è un concetto di programmazione in cui i dati sono organizzati a livelli o in cui oggetti contengono altri oggetti simili. Avrai spesso visto una struttura 'if' annidata, cioè una condizione if dentro un'altra condizione if.

Allo stesso modo, i dizionari possono essere annidati e, quindi, anche le loro comprehension possono essere annidate. Vediamo cosa significa:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)

{'first': {1.0}, 'second': {2.0}}

Questo è un esempio di dizionario annidato. nested_dict è un dizionario con le chiavi: first e second, che nei loro valori contengono oggetti dizionario. Il codice lavora con i valori del dizionario interno, li converte in float e poi combina le chiavi esterne con i nuovi valori float interni in un nuovo dizionario.

Il codice presenta anche una dictionary comprehension annidata, cioè una dictionary comprehension dentro un'altra. Le dictionary comprehension, quando annidate, possono diventare piuttosto difficili da leggere e da capire, il che va contro l'idea stessa di usare le comprehension.

Man mano che la struttura del dizionario con cui lavori si complica, anche la dictionary comprehension inizia a complicarsi. In tali situazioni, potrebbe essere meglio evitare comprehension complicate nel tuo codice.

Nota che puoi riscrivere il blocco di codice sopra anche con un for loop annidato:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)

{'first': {'a': 1.0}, 'second': {'b': 2.0}}

Considerazioni finali

Si spera che ora tu abbia imparato cosa sono i dizionari in Python, il concetto di comprehension, e perché e dove la dictionary comprehension in Python può essere utile. 

La pratica migliora il tuo Python! Scopri alcuni dei nostri migliori trucchi e consigli su Python per migliorare il tuo codice, oppure segui il nostro percorso Python Data Fundamentals per padroneggiare le cose più importanti.