Tutoriel Python : définir un dictionnaire

Table des matières

I. Introduction

Les dictionnaires sont des objets qui peuvent contenir d'autres objets (tels que des listes). Cependant, au lieu d'héberger des informations dans un ordre spécifique, ils associent chaque objet contenu à une clé (une chaîne dans la plupart des cas). Par exemple, un dictionnaire peut contenir un carnet d'adresses et chaque contact est accessible en spécifiant son nom.

II. Définir et créer un dictionnaire

1. Définition et applications des dictionnaires

Le dictionnaire est un type de données très puissant et pratique. Cela ressemble aux listes à certains égards, mais à bien d'autres égards, elles sont complètement différentes d'elles. Python utilise ce type pour représenter diverses fonctions : par exemple, à cause d'un dictionnaire spécifique, on peut trouver les attributs d'un objet.

Le dictionnaire est également un objet conteneur. Contrairement à une liste, elle n'a pas de structure séquentielle. De plus, pour accéder aux objets contenus dans le dictionnaire, il n'est pas nécessaire d'utiliser un index mais de nombreux types de clés peuvent être utilisés.

Différemment aux tuples et aux listes qui sont délimités respectivement par les parenthèses et les crochets, les dictionnaires sont délimités par des accolades {}.

Utilisez des dictionnaires dans les situations suivantes :
- Pour Compter le nombre de quelques objets. Dans ce cas, vous devez créer un dictionnaire où les clés sont des objets et les valeurs sont des quantités.
- Pour le stockage de toutes les données liées à l'objet. La clé est l'objet et la valeur est la donnée associée. Par exemple, si vous souhaitez déterminer le numéro de série du mois par son nom, vous pouvez utiliser un dictionnaire pour le déterminer ; numéro['Janvier'] = 1 ; numéro['Février'] = 2 ; etc.
- Pour définir la correspondance des objets La clé est qualifiée d'objet et la valeur est le correspondant.
- Dans le cas où vous avez besoin d'une liste simple, mais que la valeur maximale de l'indice est très grande, bien que tous les indices possibles ne soient pas utilisés (le soi-disant « liste éparse »), il est possible que vous utilisez une liste associative pour pouvoir économiser de la mémoire.

2. Créer un dictionnaire vide

a) Première méthode

La création d’un dictionnaire est aussi simple que de mettre des éléments entre accolades {} séparés par des virgules.

Exemple :

Code :

dic={};
print("dictionnaire_vide : ", dic);

Résultat d’exécution :

b) Deuxième méthode

Le mot clé dict sert aussi à construire un dictionnaire vide.

Exemple :

Code :

dic=dict();
print("dictionnaire_vide : ", dic);

Résultat d’exécution :

3. Ajout des clés et valeurs

Nous indiquons la clé à laquelle nous voulons accéder entre crochets. Dans le cas où la clé n’existe pas dans le dictionnaire, elle sera ajoutée à ce dernier en lui associant sa valeur précisée après le signe =. Sinon, l'ancienne valeur va être remplacer à la position spécifiée par la nouvelle valeur.

Syntaxe :

nom_du_dictionnaire[clé]=valeur ;

L'exemple suivant permet d’illustrer comment ajouter des clés et des valeurs à un dictionnaire vide.

Exemple :

Code 1 :

dictionnaire = {};
dictionnaire["nom"] = "Kaoutar";
dictionnaire["mot de passe"] = "#";
print(" mon dictionnaire : ", dictionnaire);

Résultat d’exécution 1 :

Code 2 :

dictionnaire = {};
dictionnaire["nom"] = "Kaoutar";
dictionnaire["mot de passe"] = "#";
dictionnaire["nom"] = "Hiba";
print(" mon dictionnaire : ", dictionnaire);

Résultat d’exécution 2 :

À la ligne 4 du deuxième code, la valeur "Kaoutar" associée à la clé "nom" a été remplacée par la valeur "Hiba". Cela devrait vous rappeler le principe de création d’une variable : si une variable n'existe pas, elle va être créée, sinon elle sera remplacée par une nouvelle valeur.

Remarque : Vous pouvez utiliser presque n'importe quel type comme clé, et n'importe quel type comme valeur.

Exemple :

Code :

########## Création d'un dictionnaire avec des clés et valeurs de type entier #########
dictionnaire1 = {1: 10, 2: 20, 3: 30, 4: 40 };
print(" mon dictionnaire 1 : ", dictionnaire1);
########## Création d'un dictionnaire avec des clés et valeurs mixtes ##########
dictionnaire2={1:"a", "nom":"kaoutar", 10.1: 8.3};
print(" mon dictionnaire 2 : ", dictionnaire2);
########## Création d'un dictionnaire en utilisant la méthode dict () ##########
dictionnaire3 = dict({1: "Lundi", 2: "Mardi", 3: "Mercredi"});
print(" mon dictionnaire 3 : ", dictionnaire3);
########## Création d'un dictionnaire avec des couples ##########
dictionnaire4 = dict([(1, "Nom"), (2, "Prénom")]);
print(" mon dictionnaire 4 : ", dictionnaire4);

Résultat d’exécution :

On donne l'impression de recréer des listes, mais ce n'est pas le cas: rappelons que les dictionnaires n'ont pas de structure séquentielle. Si vous supprimez l’index 2, par exemple, le dictionnaire est différent de la liste et ne décale pas toutes les clés dont l'index est supérieur à l'index supprimé. Ce n'est pas pour.

Résumons tout cela :

Il existe des dictionnaires dont d’autres objets peuvent exister. Ces objets sont placés et accessibles à l'aide des clés. Il faut noter qu’un dictionnaire ne peut jamais avoir deux clés identiques (comme déjà vu, la première va être remplacer par la deuxième). Cependant, rien n'empêche le dictionnaire d'avoir deux valeurs identiques.

III. Manipuler les dictionnaires

1. Accéder à la valeur d’une clé

Pour afficher une valeur d’une clé précise on procède comme suit :

Print(nom_du_dictionnaire[clé]) ;

Dans le cas où cette clé n’existe pas dans le dictionnaire, une exception de type KeyError sera déclenchée.

Exemple :

Code :

########## Création d'un dictionnaire #########
dictionnaire = {};
dictionnaire[0] = "a";
dictionnaire[1] = "b";
dictionnaire[2] = "c";
dictionnaire[3] = "d";
dictionnaire[4] = "e";
dictionnaire[5] = "f";
########## Affichage du dictionnaire créé #########
print(" mon dictionnaire : ", dictionnaire);
########## Accéder et afficher la valeur de la clé 1 #########
print(" la valeur de la clé 1 est : ", dictionnaire[0]);

Résultat d’exécution :

2. Supprimer des éléments d’un dictionnaire

Quant à la liste, vous avez deux possibilités, mais elles ont les mêmes possibilités :

La méthode del.
La méthode pop.
La méthode clear.

a) La méthode del

À l'aide de l'instruction del, vous pouvez supprimer des éléments en fonction des clés du dictionnaire.

Syntaxe :

del nom-du-dictionnaire[clé] ;

Exemple :

Code :

########## Création et affichage du dictionnaire ##########
dictionnaire = dict({1: "Lundi", 2: "Mardi", 3: "Mercredi"});
print(" mon dictionnaire avant la suppression : ", dictionnaire);
########## Supprimer la clé 2 ##########
del dictionnaire[2];
########## Afficher le dictionnaire après la suppression de la clé ##########
print(" mon dictionnaire après la suppression : ", dictionnaire);

Résultat d’exécution :

Remarque : La suppression de la clé génère automatique une suppression de la valeur associée.

b) La méthode pop

Le mot clé pop supprime également la clé spécifiée, mais retourne la valeur supprimée.

Syntaxe :

pop.nom-du-dictionnaire(clé) ;

Exemple :

Code :

########## Création et affichage du dictionnaire ##########
dictionnaire = {1: "Lundi", 2: "Mardi", 3: "Mercredi"};
print(" mon dictionnaire avant la suppression : ", dictionnaire);
########## Supprimer l'élément dont la clé est 2 et renvoyer la valeur associée #########
pop.dictionnaire(2);
########## Afficher le dictionnaire après la suppression de l'élément ##########
print(" mon dictionnaire après la suppression : ", dictionnaire);

Résultat d’exécution :

c) La méthode clear

La méthode clear efface tous les éléments du dictionnaire. Notez que l'ensemble des crochets vides représente un dictionnaire sans éléments.

Syntaxe :

nom-du-dictionnaire.clear() ;

Exemple :

Code :

########## vider le dictionnaire ##########
dictionnaire={1:"Kaoutar", "ville":"Casablanca", "âge":22, 1.60: 68};
dictionnaire.clear();
dictionnaire

Résultat d’exécution :

3. Parcourir un dictionnaire

Comme vous pouvez l'imaginer, parcourir un dictionnaire n'est pas la même chose que parcourir une liste. La différence n'est pas grande, mais généralement, nous utilisons des méthodes destinées que pour les dictionnaires.

a) Parcourir les clés

La manière la plus simple pour parcourir les clés d’un dictionnaire est d’utiliser une boucle for. Cette méthode est applicable pour listes comme pour les dictionnaires, la seule différence c’est que les clés ne s’affichent pas dans le même ordre précisé lors de la création d’un dictionnaire. Cela est dû principalement à la structure non ordonnée du dictionnaire comme mentionné auparavant dans notre définition.

Exemple :

Code :

dictionnaire={1:"Kaoutar", "ville":"Casablanca", "âge":22, 1.60: 68};
for clé in dictionnaire:
print(clé)

Résultat d’exécution :

En plus d’utiliser la boucle for, la méthode keys renvoie une liste de clés contenues dans le dictionnaire. En fait, ce n'est pas une liste (essayez de taper l’instruction dictionnaire.keys () dans l'interpréteur), mais sa séquence est itérée comme une liste.

Syntaxe :

nom_du_dictionnaire.keys()

Exemple :

Code :

dictionnaire={"jour":"Lundi", "Ville":"Casablanca", "sexe": "féminin", "âge":22};
for clé in dictionnaire.keys():
print(clé)
dictionnaire.keys()

Résultat d’exécution :

Remarque : Cette méthode fait partie de la classe dict. Généralement, elle est la plus utilisée grâce à sa lisibilité de lecture ; c’est-à-dire, en lisant l’instruction dictionnaire.keys() on sait bien qu’on est en train de parcourir une liste de clés.

b) Parcourir les valeurs

Vous pouvez également parcourir les valeurs contenues dans le dictionnaire. Pour cela, nous utilisons la méthode values.

Syntaxe :

nom_du_dictionnaire.values()

Exemple :

Code :

dictionnaire={"jour":"Lundi", "Ville":"Casablanca", "sexe": "féminin", "âge":22};
for valeur in dictionnaire.values():
print(valeur)

Résultat d’exécution :

Cette méthode est rarement utilisée pour parcourir un dictionnaire, car le fait de parcourir la liste des clés est plus pratique et suffisant pour obtenir la valeur correspondante. Cependant, nous pouvons bien sûr également l'utiliser dans une condition comme l’illustre l’exemple suivant :

Exemple :

Code :

étudiants={"kaoutar": 22, "Hiba": 21, "Yasmine": 20, "Achraf": 23};
if 21 in étudiants.values():
print("Un des étudiants est à l'âge de 21 ans.")

Résultat d’exécution :

c) Parcourir les clés et les valeurs simultanément

Pour effectuer une opération de parcours des clés et des valeurs à la fois sur un dictionnaire, nous utilisons la méthode items. Il renvoie une liste de paires clé: valeur sous la forme d'un tuple.

Syntaxe :

nom-du-dictionnaire.items()

Voyons par cet exemple comment l'utiliser :

Exemple :

Code :

dictionnaire={1:"Kaoutar", "ville":"Casablanca", "âge":22, 1.60: 68};
for clé, valeur in dictionnaire.items():
print("La clé {} contient la valeur {}.".format(clé, valeur))

Résultat d’exécution :

IV. Résumé

Un dictionnaire est un objet conteneur qui associe des clés à des valeurs.
Pour créer un dictionnaire, utilisez la syntaxe suivante : Dictionnaire = {clé1: valeur1, clé2: valeur2, cléN: valeurN}. Ou bien, utilisez la méthode dict.
Vous pouvez ajouter ou remplacer des éléments dans le dictionnaire : Dictionnaire [clé] = valeur.
Pour supprimer les clés d'un dictionnaire ainsi qu'aux valeurs associées à ces clés, vous pouvez procéder par trois méthodes différentes :
- Le mot-clé del.
- La méthode pop ().
- La méthode clean ().
Vous pouvez parcourir le dictionnaire à l'aide des méthodes suivantes :
- keys () : Pour parcourir les clés.
- values () : Pour parcourir les valeurs.
- items (): Pour parcourir les paires clé-valeur.

V. Exercices d’application

a) Enoncé 1

Ecrire un programme en Python qui permet à l'utilisateur de saisir du texte et lui renvoie un dictionnaire. Les clés du dictionnaire sont les mots du texte entré, et la valeur est la longueur des mots qui composent le texte.

Exemple de texte :

Texte : Python est un langage de programmation, le programme doit retourner le dictionnaire :

d={'Python': 6, 'est': 3, 'un': 2, 'langage': 7, 'de': 2, 'programmation': 13}

b) Corrigé 1

Code :

Texte = input("Tapez un texte: ")
Liste = Texte.split()
dictionnaire = dict({})
for mot in Liste:
dictionnaire[mot] = len(mot)
print(dictionnaire)

Résultat d’exécution :

c) Enoncé 2

Soit un dictionnaire contenant les noms des étudiants associés à leurs âges :

d={'Kaoutar': 22, 'Hiba': 21, 'Yasmine': 17, 'David': 23, 'Katy': 15}

A partir du dictionnaire d, créer un dictionnaire nommé majeur qui contiendra que les personnes majeures avec leurs âges et un autre dictionnaire nommé mineur qui va contenir les personnes mineures avec leurs âges.

d) Corrigé 2

Code :

d={'Kaoutar': 22, 'Hiba': 21, 'Yasmine': 17, 'David': 23, 'Katy': 15}
majeur = dict({})
mineur = dict({})
for clé, valeur in d.items():
if (valeur mineur[clé] = valeur
else:
majeur[clé] = valeur
print("La liste des personnes majeures est", majeur)
print("La liste des personnes mineures est", mineur)

Résultat d’exécution :

VI. Conclusion

Un dictionnaire est un type de donnée non ordonnée de paires clé / valeur. Chaque clé peut accéder à la valeur qui lui est associée. Les dictionnaires sont plus puissants que les listes et sont parfaits pour les tests d'adhésion. En effet, puisqu'il s'agit d'une implémentation d'une table de hachage et non d'une séquence, la vitesse d'exécution du test d'appartenance est indépendante du nombre d'éléments contenus dans le dictionnaire.

Article publié le 01 Octobre 2020par Kaoutar OUAZZINE