Comprensione dei dizionari in Python 3

Introduzione

Il dizionario è il tipo di mappatura incorporato di Python. I dizionari mappano chiavi a valori e queste coppie chiave-valore forniscono un modo utile per memorizzare i dati in Python.

Tipicamente usati per contenere dati correlati, come le informazioni contenute in un ID o in un profilo utente, i dizionari sono costruiti con parentesi graffe su entrambi i lati { }.

A dictionary looks like this:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

Oltre alle parentesi graffe, ci sono anche due punti (:) all’interno del dizionario.

Le parole a sinistra dei due punti sono le chiavi. Le chiavi possono essere composte da qualsiasi tipo di dati immutabile. Le chiavi nel dizionario sopra sono:

• 'username'
• 'online'
• 'followers'

Ogni chiave nell’esempio sopra è un valore stringa.

Le parole a destra dei due punti sono i valori. I valori possono essere composti da qualsiasi tipo di dati. I valori nel dizionario sopra sono:

• 'sammy-shark'
• Vero
• 987

Ogni di questi valori è una stringa, un Booleano, o un intero.

Stampiamo il dizionario sammy:

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': True}

Osservando l’output, l’ordine delle coppie chiave-valore potrebbe essere cambiato. Nella versione 3.5 e precedenti di Python, il tipo di dato dizionario è non ordinato. Tuttavia, dalla versione 3.6 in poi di Python, il tipo di dato dizionario rimane ordinato. Indipendentemente dal fatto che il dizionario sia ordinato o meno, le coppie chiave-valore rimarranno intatte, consentendoci di accedere ai dati in base al loro significato relazionale.

Prerequisiti

Dovresti avere Python 3 installato e un ambiente di programmazione configurato sul tuo computer o server. Se non hai un ambiente di programmazione configurato, puoi fare riferimento alle guide di installazione e configurazione per un ambiente di programmazione locale o per un ambiente di programmazione sul tuo server appropriato per il tuo sistema operativo (Ubuntu, CentOS, Debian, ecc.).

Accesso agli elementi del dizionario

Possiamo chiamare i valori di un dizionario facendo riferimento alle chiavi correlate.

Accesso agli elementi dati con le chiavi

Poiché i dizionari offrono coppie chiave-valore per memorizzare i dati, possono essere elementi importanti nel tuo programma Python.

Se vogliamo isolare il nome utente di Sammy, possiamo farlo chiamando sammy['username']. Stampiamo quello:

print(sammy['username'])

Output
sammy-shark

I dizionari si comportano come un database nel senso che invece di chiamare un intero per ottenere un particolare valore di indice come faresti con una lista, assegni un valore a una chiave e puoi chiamare quella chiave per ottenere il suo valore correlato.

Invocando la chiave 'username' riceviamo il valore di quella chiave, che è 'sammy-shark'.

I valori rimanenti nel dizionario sammy possono essere chiamati allo stesso modo utilizzando lo stesso formato:

sammy['followers']
# Restituisce 987

sammy['online']
# Restituisce True

Facendo uso delle coppie chiave-valore dei dizionari, possiamo fare riferimento alle chiavi per recuperare i valori.

Utilizzo dei Metodi per Accedere agli Elementi

Oltre all’utilizzo delle chiavi per accedere ai valori, possiamo anche lavorare con alcuni metodi integrati:

• dict.keys() isola le chiavi
• dict.values() isola i valori
• dict.items() restituisce gli elementi in un formato di lista di coppie di tuple (chiave, valore)

Per restituire le chiavi, useremmo il metodo dict.keys(). Nel nostro esempio, quello utilizzerebbe il nome della variabile e sarebbe sammy.keys(). Passiamolo quindi a un metodo print() e guardiamo l’output:

print(sammy.keys())

Output
dict_keys(['followers', 'username', 'online'])

Riceviamo un output che posiziona le chiavi all’interno di un oggetto di visualizzazione iterabile della classe dict_keys. Le chiavi vengono quindi stampate in un formato di lista.

Questo metodo può essere utilizzato per interrogare tra i dizionari. Ad esempio, possiamo dare un’occhiata alle chiavi comuni condivise tra due strutture dati dizionario:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}
jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

for common_key in sammy.keys() & jesse.keys():
    print(sammy[common_key], jesse[common_key])

Il dizionario sammy e il dizionario jesse sono ciascuno un dizionario di profilo utente.

I loro profili hanno chiavi diverse, tuttavia, perché Sammy ha un profilo sociale con follower associati, e Jesse ha un profilo di gioco con punti associati. Le 2 chiavi che hanno in comune sono lo stato di username e online, che possiamo trovare quando eseguiamo questo piccolo programma:

Output
sammy-shark JOctopus
True False

Certo, potremmo certamente migliorare il programma per rendere l’output più leggibile per l’utente, ma questo illustra che dict.keys() può essere utilizzato per controllare attraverso vari dizionari per vedere cosa condividono in comune o no. Questo è particolarmente utile per i dizionari di grandi dimensioni.

Allo stesso modo, possiamo usare il metodo dict.values() per interrogare i valori nel dizionario sammy, che sarebbe costruito come sammy.values(). Stampiamo quelli:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

print(sammy.values())

Output
dict_values([True, 'sammy-shark', 987])

Sia il metodo keys() che il metodo values() restituiscono elenchi non ordinati delle chiavi e dei valori presenti nel dizionario sammy con gli oggetti di visualizzazione dict_keys e dict_values rispettivamente.

Se siamo interessati a tutti gli elementi in un dizionario, possiamo accedervi con il metodo items():

print(sammy.items())

Output
dict_items([('online', True), ('username', 'sammy-shark'), ('followers', 987)])

Il formato restituito di questo è una lista composta da coppie di tuple (chiave, valore) con l’oggetto di visualizzazione dict_items.

Possiamo iterare sul formato della lista restituita con un ciclo for. Ad esempio, possiamo stampare ogni chiave e valore di un dato dizionario, e quindi renderlo più leggibile aggiungendo una stringa:

for key, value in sammy.items():
    print(key, 'is the key for the value', value)

Output
online is the key for the value True
followers is the key for the value 987
username is the key for the value sammy-shark

Il ciclo for sopra ha iterato sugli elementi all’interno del dizionario sammy e ha stampato le chiavi e i valori riga per riga, con informazioni per renderlo più comprensibile agli umani.

Possiamo utilizzare metodi integrati per accedere agli elementi, ai valori e alle chiavi dalle strutture dati dei dizionari.

Modifica dei Dizionari

I dizionari sono una struttura dati mutabile, quindi è possibile modificarli. In questa sezione, esamineremo l’aggiunta e la cancellazione degli elementi del dizionario.

Aggiunta e Modifica degli Elementi del Dizionario

Senza utilizzare un metodo o una funzione, è possibile aggiungere coppie chiave-valore ai dizionari utilizzando la seguente sintassi:

dict[key] = value

Vedremo come funziona nella pratica aggiungendo una coppia chiave-valore a un dizionario chiamato usernames:

usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

usernames['Drew'] = 'squidly'

print(usernames)

Output
{'Drew': 'squidly', 'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

Vediamo ora che il dizionario è stato aggiornato con la coppia chiave-valore 'Drew': 'squidly'. Poiché i dizionari possono essere disordinati, questa coppia può comparire in qualsiasi punto dell’output del dizionario. Se utilizziamo il dizionario usernames successivamente nel nostro file di programma, includerà la coppia chiave-valore aggiuntiva.

Inoltre, questa sintassi può essere utilizzata per modificare il valore assegnato a una chiave. In questo caso, faremo riferimento a una chiave esistente e passeremo un valore diverso ad essa.

Consideriamo un dizionario drew che è uno degli utenti in una rete data. Diremo che questo utente ha avuto un aumento di follower oggi, quindi dobbiamo aggiornare il valore intero passato alla chiave 'followers'. Utilizzeremo la funzione print() per verificare che il dizionario sia stato modificato.

drew = {'username': 'squidly', 'online': True, 'followers': 305}

drew['followers'] = 342

print(drew)

Output
{'username': 'squidly', 'followers': 342, 'online': True}

Nell’output, vediamo che il numero di follower è passato dal valore intero di 305 a 342.

Possiamo utilizzare questo metodo per aggiungere coppie chiave-valore ai dizionari con input dell’utente. Scriviamo un programma rapido, usernames.py, che viene eseguito sulla riga di comando e consente all’utente di inserire più nomi e nomi utente associati:

# Definisci il dizionario originale
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

# Configura un ciclo while per iterare
while True:

    # Richiedi all'utente di inserire un nome
    print('Enter a name:')

    # Assegna alla variabile nome
    name = input()

    # Verifica se il nome è nel dizionario e stampa un feedback
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # Se il nome non è nel dizionario...
    else:

        # Fornisci un feedback        
        print('I don\'t have ' + name + '\'s username, what is it?')

        # Inserisci un nuovo nome utente per il nome associato
        username = input()

        # Assegna il valore del nome utente alla chiave del nome
        usernames[name] = username

        # Stampa un feedback che i dati sono stati aggiornati
        print('Data updated.')

Eseguiamo il programma sulla riga di comando:

python usernames.py

Quando eseguiamo il programma otterremo qualcosa di simile all’output seguente:

Output
Enter a name:
Sammy
sammy-shark is the username of Sammy
Enter a name:
Jesse
I don't have Jesse's username, what is it?
JOctopus
Data updated.
Enter a name:

Quando abbiamo finito di testare il programma, possiamo premere CTRL + C per uscire dal programma. È possibile impostare un trigger per chiudere il programma (come ad esempio digitare la lettera q) con una dichiarazione condizionale per migliorare il codice.

Questo mostra come è possibile modificare i dizionari interattivamente. Con questo particolare programma, non appena si esce dal programma con CTRL + C, si perderanno tutti i dati a meno che non si implementi un modo per gestire la lettura e la scrittura dei file.

Possiamo anche aggiungere e modificare i dizionari utilizzando il metodo dict.update(). Questo è diverso dal metodo append() disponibile nelle liste.

Nel dizionario jesse qui sotto, aggiungiamo la chiave 'followers' e assegniamo un valore intero con jesse.update(). Successivamente, stampiamo il dizionario aggiornato con print().

jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

jesse.update({'followers': 481})

print(jesse)

Output
{'followers': 481, 'username': 'JOctopus', 'points': 723, 'online': False}

Dall’output, possiamo vedere che abbiamo aggiunto con successo la coppia chiave-valore 'followers': 481 al dizionario jesse.

Possiamo anche utilizzare il metodo dict.update() per modificare una coppia chiave-valore esistente sostituendo un determinato valore per una chiave specifica.

Cambiare lo stato online di Sammy da True a False nel dizionario sammy:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

sammy.update({'online': False})

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': False}

La riga sammy.update({'online': False}) fa riferimento alla chiave esistente 'online' e modifica il suo valore booleano da True a False. Quando chiamiamo print() sul dizionario, vediamo che l’aggiornamento avviene nell’output.

Per aggiungere elementi ai dizionari o modificare valori, possiamo utilizzare sia la sintassi dict[key] = value che il metodo dict.update().

Eliminazione degli elementi del dizionario

Come è possibile aggiungere coppie chiave-valore e cambiare valori all’interno del tipo di dati dizionario, è anche possibile eliminare elementi all’interno di un dizionario.

Per rimuovere una coppia chiave-valore da un dizionario, utilizzeremo la seguente sintassi:

del dict[key]

Prendiamo il dizionario jesse che rappresenta uno degli utenti. Diremo che Jesse non sta più utilizzando la piattaforma online per giocare, quindi rimuoveremo l’elemento associato alla chiave 'points'. Quindi, stampiamo il dizionario per confermare che l’elemento è stato eliminato:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

del jesse['points']

print(jesse)

Output
{'online': False, 'username': 'JOctopus', 'followers': 481}

La riga del jesse['points'] rimuove la coppia chiave-valore 'points': 723 dal dizionario jesse.

Se volessimo eliminare un dizionario di tutti i suoi valori, possiamo farlo con il metodo dict.clear(). Questo manterrà un dato dizionario nel caso in cui ne abbiamo bisogno successivamente nel programma, ma non conterrà più alcun elemento.

Eliminiamo tutti gli elementi all’interno del dizionario jesse:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

jesse.clear()

print(jesse)

Output
{}

L’output mostra che ora abbiamo un dizionario vuoto privo di coppie chiave-valore.

Se non abbiamo più bisogno di un dizionario specifico, possiamo usare del per eliminarlo completamente:

del jesse

print(jesse)

Quando eseguiamo una chiamata a print() dopo aver eliminato il dizionario jesse, riceveremo il seguente errore:

Output
...
NameError: name 'jesse' is not defined

Poiché i dizionari sono tipi di dati mutabili, possono essere aggiunti, modificati e avere elementi rimossi e cancellati.

Conclusione

Questo tutorial ha illustrato la struttura dati del dizionario in Python. I dizionari sono composti da coppie chiave-valore e forniscono un modo per memorizzare dati senza fare affidamento sull’indicizzazione. Ciò ci consente di recuperare valori in base al loro significato e alla relazione con altri tipi di dati.

Da qui, puoi apprendere ulteriori informazioni su altri tipi di dati nel nostro tutorial “Comprendere i Tipi di Dati“.

Puoi vedere il tipo di dato dizionario utilizzato in progetti di programmazione come web scraping con Scrapy.