Comprendre les dictionnaires en Python 3

Introduction

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

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

Un dictionnaire ressemble à ceci :

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 tout type de données immuable. Les clés dans le dictionnaire ci-dessus sont :

'username'

'online'

'followers'

Chacune des clés de l'exemple ci-dessus est une valeur de chaîne.

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

'sammy-shark'

True

987

Chacune de ces valeurs est soit une chaîne, un booléen ou un entier.

Imprimons le dictionnaire sammy :

print(sammy)

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

En regardant la sortie, l'ordre des paires clé-valeur peut avoir changé. Dans les versions 3.5 de Python et antérieures, le type de données dictionnaire est non ordonné. Cependant, dans les versions 3.6 et ultérieures de Python, le type de données dictionnaire reste ordonné. Qu'il soit ordonné ou non, les paires clé-valeur resteront intactes, ce qui nous permet d'accéder aux données en fonction de leur signification relationnelle.

Conditions préalables

Vous devriez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n'avez pas d'environnement de programmation configuré, vous pouvez consulter les guides d'installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur, approprié à votre système d'exploitation (Ubuntu, CentOS, Debian, etc.).

Accéder aux éléments du dictionnaire

Nous pouvons appeler les valeurs d'un dictionnaire en référant aux clés associées.

Accéder 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'])

sammy-shark

Les dictionnaires se comportent comme une base de données en ce sens qu'au lieu d'appeler un entier pour obtenir une valeur d'index particulière comme vous le feriez avec une liste, vous assignez 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 également être appelées en utilisant le même format :

sammy['followers']
Returns 987

sammy['online']
Returns True

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

Utiliser 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 certaines méthodes intégrées :

• dict.keys() isole les clés
• dict.values() isole les valeurs
• dict.items() renvoie des éléments au format liste de paires de tuples (clé, valeur)

Pour retourner 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 regardons le résultat :

print(sammy.keys())

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 au format de liste.

Cette méthode peut être utilisée pour interroger des dictionnaires. Par exemple, nous pouvons examiner les clés communes partagées entre deux structures de données de dictionnaires :

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, parce que Sammy a un profil social avec des abonnés associés, et Jesse a un profil de jeu avec des points associés. Les 2 clés qu'ils ont en commun sont nom d'utilisateur et statut en ligne, que nous pouvons trouver lorsque nous exécutons ce petit programme :

sammy-shark JOctopus
True False

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

De la même manière, 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())

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

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

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

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

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

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 les valeurs ligne par ligne, avec des informations pour faciliter la compréhension 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.

Modifier des dictionnaires

Les dictionnaires sont une structure de données mutable, donc vous pouvez les modifier. Dans cette section, nous allons aborder l'ajout et la suppression d'éléments dans un dictionnaire.

Ajouter et modifier des é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 allons examiner comment cela fonctionne en pratique en ajoutant une paire clé-valeur à un dictionnaire appelé noms d'utilisateur :

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

usernames['Drew'] = 'squidly'

print(usernames)

{'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 non ordonné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 comprendra la paire clé-valeur supplémentaire.

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

Considérons un dictionnaire drew qui est un des utilisateurs d'un réseau donné. Nous dirons que cet utilisateur a eu une augmentation de ses abonnés 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)

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

Dans la sortie, nous voyons que le nombre de abonnés a augmenté de la valeur entière de 305 à 342.

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

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

Set up while loop to iterate
while True:

    # Request user to enter a name
    print('Enter a name:')

    # Assign to name variable
    name = input()

    # Check whether name is in the dictionary and print feedback
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # If the name is not in the dictionary...
    else:

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

        # Take in a new username for the associated name
        username = input()

        # Assign username value to name key
        usernames[name] = username

        # Print feedback that the data was updated
        print('Data updated.')

Exécutons le programme dans la ligne de commande :

python usernames.py

Lorsque nous exécutons le programme, nous obtiendrons une sortie semblable à celle-ci :

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 terminé 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 instruction conditionnelle pour améliorer le code.

Ceci montre comment vous pouvez modifier des dictionnaires de manière interactive. Avec ce programme en particulier, dès que vous quittez le programme avec CTRL + C, vous perdrez toutes vos données à moins que vous ne mettiez 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(). Après cela, imprimons le dictionnaire mis à jour avec print().

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

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

print(jesse)

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

D'après la sortie, nous pouvons voir que nous avons réussi à ajouter 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.

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

{'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() pour afficher le dictionnaire, nous voyons la mise à jour se produire dans la sortie.

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

Suppression des éléments du dictionnaire

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

Pour supprimer une paire clé-valeur d'un dictionnaire, nous allons utiliser la syntaxe suivante :

del dict[key]

Prenons le dictionnaire jesse qui représente l'un des utilisateurs. Nous allons dire 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)

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

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

Si nous souhaitons vider un dictionnaire de toutes ses valeurs, nous pouvons le faire avec la méthode dict.clear(). Cela permettra de conserver 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.

Retirons tous les éléments du dictionnaire jesse :

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

jesse.clear()

print(jesse)

{}

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 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 :

...
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 parcouru la structure de données de dictionnaire en Python. Les dictionnaires sont constitués de paires clé-valeur et offrent 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 ici, 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.