Compréhension des dictionnaires en Python 3

Introduction

Le dictionnaire est le type de mapping intégré de Python. Les dictionnaires font correspondre des clés à des valeurs et ces paires clé-valeur fournissent un moyen utile de stocker des données en Python.

Généralement utilisés pour contenir des données qui sont liées, comme les informations contenues dans un identifiant ou un profil utilisateur, les dictionnaires sont construits avec des accolades de chaque côté { }.

A dictionary looks like this:

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

En plus des accolades, il y a aussi des deux-points (:) dans tout le dictionnaire.

Les mots à gauche des deux-points sont les clés. Les clés peuvent être constituées de n’importe quel type de données immuable. Les clés dans le dictionnaire ci-dessus sont :

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

Chacune des clés dans l’exemple ci-dessus sont des valeurs string.

Les mots à droite des deux-points sont les valeurs. Les valeurs peuvent être composées de n’importe quel type de données. Les valeurs dans le dictionnaire ci-dessus sont :

• 'sammy-shark'
• Vrai
• 987

Chacune de ces valeurs est soit une chaîne de caractères, Boolean, ou un entier.

Imprimons le dictionnaire sammy:

print(sammy)

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

En regardant la sortie, l’ordre des paires clé-valeur peut avoir changé. Dans la version Python 3.5 et antérieure, le type de données dictionnaire est non ordonné. Cependant, dans la version Python 3.6 et ultérieure, le type de données dictionnaire reste ordonné. Quelle que soit la manière dont le dictionnaire est ordonné ou non, les paires clé-valeur resteront intactes, nous permettant d’accéder aux données en fonction de leur signification relationnelle.

Prérequis

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou votre serveur. Si vous n’avez pas d’environnement de programmation configuré, vous pouvez vous référer aux guides d’installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur adapté à votre système d’exploitation (Ubuntu, CentOS, Debian, etc.).

Accès aux éléments du dictionnaire

Nous pouvons appeler les valeurs d’un dictionnaire en faisant référence aux clés associées.

Accès aux éléments de données avec des clés

Parce que les dictionnaires offrent des paires clé-valeur pour stocker des données, ils peuvent être des éléments importants dans votre programme Python.

Si nous voulons isoler le nom d’utilisateur de Sammy, nous pouvons le faire en appelant sammy['username']. Imprimons cela :

print(sammy['username'])

Output
sammy-shark

Les dictionnaires se comportent comme une base de données dans le sens où au lieu d’appeler un entier pour obtenir une valeur d’index particulière comme vous le feriez avec une liste, vous attribuez une valeur à une clé et pouvez appeler cette clé pour obtenir sa valeur associée.

En invoquant la clé 'username', nous recevons la valeur de cette clé, qui est 'sammy-shark'.

Les valeurs restantes dans le dictionnaire sammy peuvent être également appelées en utilisant le même format :

sammy['followers']
# Renvoie 987

sammy['online']
# Renvoie True

En utilisant les paires clé-valeur des dictionnaires, nous pouvons référencer des clés pour récupérer des valeurs.

Utilisation des méthodes pour accéder aux éléments

En plus d’utiliser des clés pour accéder aux valeurs, nous pouvons également travailler avec quelques méthodes intégrées :

• dict.keys() isole les clés
• dict.values() isole les valeurs
• dict.items() renvoie les éléments sous forme de paires de tuples (clé, valeur) dans une liste

Pour obtenir les clés, nous utiliserions la méthode dict.keys(). Dans notre exemple, cela utiliserait le nom de la variable et serait sammy.keys(). Passons cela à une méthode print() et examinons la sortie :

print(sammy.keys())

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

Nous recevons une sortie qui place les clés dans un objet de vue itérable de la classe dict_keys. Les clés sont ensuite imprimées dans un format de liste.

Cette méthode peut être utilisée pour interroger à travers des dictionnaires. Par exemple, nous pouvons jeter un coup d’œil aux clés communes partagées entre deux structures de données de dictionnaire :

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])

Le dictionnaire sammy et le dictionnaire jesse sont chacun un dictionnaire de profil utilisateur.

Leurs profils ont des clés différentes, cependant, car Sammy a un profil social avec des followers associés et Jesse a un profil de jeu avec des points associés. Les 2 clés qu’ils ont en commun sont username et l’état online, que nous pouvons trouver lorsque nous exécutons ce petit programme :

Output
sammy-shark JOctopus
True False

Nous pourrions certainement améliorer le programme pour rendre la sortie plus lisible pour l’utilisateur, mais ceci illustre que dict.keys() peut être utilisé pour vérifier à travers divers dictionnaires ce qu’ils ont en commun ou non. C’est particulièrement utile pour les grands dictionnaires.

De même, nous pouvons utiliser la méthode dict.values() pour interroger les valeurs dans le dictionnaire sammy, qui serait construit comme sammy.values(). Imprimons-les :

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

print(sammy.values())

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

Les deux méthodes keys() et values() renvoient des listes non triées des clés et des valeurs présentes dans le dictionnaire sammy avec les objets de vue dict_keys et dict_values respectivement.

Si nous sommes intéressés par tous les éléments d’un dictionnaire, nous pouvons y accéder avec la méthode items() :

print(sammy.items())

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

Le format retourné est une liste constituée de paires de tuples (clé, valeur) avec l’objet de vue dict_items.

Nous pouvons itérer sur le format de liste retourné avec une boucle for. Par exemple, nous pouvons imprimer chacune des clés et valeurs d’un dictionnaire donné, puis le rendre plus lisible en ajoutant une chaîne de caractères :

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

La boucle for ci-dessus a itéré sur les éléments du dictionnaire sammy et a imprimé les clés et valeurs ligne par ligne, avec des informations pour le rendre plus compréhensible par les humains.

Nous pouvons utiliser des méthodes intégrées pour accéder aux éléments, aux valeurs et aux clés des structures de données de dictionnaire.

Modification des dictionnaires

Les dictionnaires sont des structures de données mutables, vous pouvez donc les modifier. Dans cette section, nous aborderons l’ajout et la suppression d’éléments de dictionnaire.

Ajout et modification d’éléments de dictionnaire

Sans utiliser de méthode ou de fonction, vous pouvez ajouter des paires clé-valeur aux dictionnaires en utilisant la syntaxe suivante :

dict[key] = value

Nous verrons comment cela fonctionne en pratique en ajoutant une paire clé-valeur à un dictionnaire appelé usernames :

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

usernames['Drew'] = 'squidly'

print(usernames)

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

Nous voyons maintenant que le dictionnaire a été mis à jour avec la paire clé-valeur 'Drew': 'squidly'. Comme les dictionnaires peuvent être désordonnés, cette paire peut apparaître n’importe où dans la sortie du dictionnaire. Si nous utilisons le dictionnaire usernames plus tard dans notre fichier de programme, il inclura la paire clé-valeur supplémentaire.

De plus, cette syntaxe peut être utilisée pour modifier la valeur attribuée à une clé. Dans ce cas, nous référencerons une clé existante et lui attribuerons une valeur différente.

Considérons un dictionnaire drew qui est l’un des utilisateurs sur un réseau donné. Nous dirons que cet utilisateur a obtenu une augmentation de followers aujourd’hui, donc nous devons mettre à jour la valeur entière passée à la clé 'followers'. Nous utiliserons la fonction print() pour vérifier que le dictionnaire a été modifié.

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

drew['followers'] = 342

print(drew)

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

Dans la sortie, nous voyons que le nombre de followers est passé de la valeur entière de 305 à 342.

Nous pouvons utiliser cette méthode pour ajouter des paires clé-valeur aux dictionnaires avec une saisie utilisateur. Écrivons un programme rapide, usernames.py, qui s’exécute sur la ligne de commande et permet à l’utilisateur d’ajouter plus de noms et de noms d’utilisateur associés:

# Définir le dictionnaire d'origine
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

# Configurer la boucle while pour itérer
while True:

    # Demander à l'utilisateur d'entrer un nom
    print('Enter a name:')

    # Affecter à la variable de nom
    name = input()

    # Vérifier si le nom est dans le dictionnaire et afficher les commentaires
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # Si le nom n'est pas dans le dictionnaire...
    else:

        # Fournir des commentaires
        print('I don\'t have ' + name + '\'s username, what is it?')

        # Saisir un nouveau nom d'utilisateur pour le nom associé
        username = input()

        # Affecter la valeur du nom d'utilisateur à la clé de nom
        usernames[name] = username

        # Afficher les commentaires indiquant que les données ont été mises à jour
        print('Data updated.')

Exécutons le programme sur la ligne de commande:

python usernames.py

Lorsque nous exécutons le programme, nous obtiendrons quelque chose comme la sortie suivante :

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:

Lorsque nous avons fini de tester le programme, nous pouvons appuyer sur CTRL + C pour quitter le programme. Vous pouvez configurer un déclencheur pour quitter le programme (comme taper la lettre q) avec une déclaration conditionnelle pour améliorer le code.

Cela montre comment vous pouvez modifier les dictionnaires de manière interactive. Avec ce programme particulier, dès que vous quittez le programme avec CTRL + C, vous perdrez toutes vos données à moins de mettre en œuvre un moyen de gérer la lecture et l’écriture de fichiers.

Nous pouvons également ajouter et modifier des dictionnaires en utilisant la méthode dict.update(). Cela diffère de la méthode append() disponible dans les listes.

Dans le dictionnaire jesse ci-dessous, ajoutons la clé 'followers' et donnons-lui une valeur entière avec jesse.update(). Ensuite, imprimons() le dictionnaire mis à jour.

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

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

print(jesse)

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

À partir de la sortie, nous pouvons voir que nous avons ajouté avec succès la paire clé-valeur 'followers': 481 au dictionnaire jesse.

Nous pouvons également utiliser la méthode dict.update() pour modifier une paire clé-valeur existante en remplaçant une valeur donnée pour une clé spécifique.

Modifions le statut en ligne de Sammy de True à False dans le dictionnaire sammy:

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

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

print(sammy)

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

La ligne sammy.update({'online': False}) fait référence à la clé existante 'online' et modifie sa valeur booléenne de True à False. Lorsque nous appelons print() sur le dictionnaire, nous voyons la mise à jour se produire dans la sortie.

Pour ajouter des éléments aux dictionnaires ou modifier des valeurs, nous pouvons utiliser soit la syntaxe dict[key] = value soit la méthode dict.update().

Suppression d’éléments de dictionnaire

Tout comme vous pouvez ajouter des paires clé-valeur et modifier des valeurs dans le type de données de dictionnaire, vous pouvez également supprimer des éléments dans un dictionnaire.

Pour supprimer une paire clé-valeur d’un dictionnaire, nous utiliserons la syntaxe suivante:

del dict[key]

Prenez le dictionnaire jesse qui représente l’un des utilisateurs. Disons que Jesse n’utilise plus la plateforme en ligne pour jouer à des jeux, donc nous allons supprimer l’élément associé à la clé 'points'. Ensuite, nous imprimerons le dictionnaire pour confirmer que l’élément a été supprimé:

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

del jesse['points']

print(jesse)

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

La ligne del jesse['points'] supprime la paire clé-valeur 'points': 723 du dictionnaire jesse.

Si nous voulons vider un dictionnaire de toutes ses valeurs, nous pouvons le faire avec la méthode dict.clear(). Cela conservera un dictionnaire donné au cas où nous aurions besoin de l’utiliser plus tard dans le programme, mais il ne contiendra plus aucun élément.

Supprimons tous les éléments du dictionnaire jesse:

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

jesse.clear()

print(jesse)

Output
{}

La sortie montre que nous avons maintenant un dictionnaire vide, dépourvu de paires clé-valeur.

Si nous n’avons plus besoin d’un dictionnaire spécifique, nous pouvons l’utiliser del pour nous en débarrasser entièrement:

del jesse

print(jesse)

Lorsque nous exécutons un appel à print() après avoir supprimé le dictionnaire jesse, nous recevrons l’erreur suivante:

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

Parce que les dictionnaires sont des types de données mutables, ils peuvent être ajoutés, modifiés et avoir des éléments supprimés et effacés.

Conclusion

Ce tutoriel a passé en revue la structure de données de dictionnaire en Python. Les dictionnaires sont constitués de paires clé-valeur et fournissent un moyen de stocker des données sans se fier à l’indexation. Cela nous permet de récupérer des valeurs en fonction de leur signification et de leur relation avec d’autres types de données.

À partir de là, vous pouvez en apprendre davantage sur d’autres types de données dans notre tutoriel « Comprendre les types de données ».

Vous pouvez voir le type de données dictionnaire utilisé dans des projets de programmation tels que le web scraping avec Scrapy.