Dictionnaire Définition d’un dictionnaire. Opérations sur les dictionnaires. Accès, suppression et ajout d’éléments du dictionnaire. Fonctions permettant de manipuler les dictionnaires. Clés de dictionnaire. Exemples.

Les dictionnaires Les types composites (chaînes de caractères, listes et tuples) considérés jusqu’à maintenant étaient tous des séquences, i.e. des suites ordonnées d’éléments. On peut accéder à un élément d’une séquence à partir de sa position. Un dictionnaire ressemble à une liste et est modifiable mais n’est pas une séquence car les éléments enregistrés ne sont pas disposés dans un ordre immuable. On peut accéder à un élément d’un dictionnaire à partir d’une clé. Cette clé peut être une chaîne, un nombre ou même d’un type composite sous certaines conditions. On ne peut pas modifier les clés d’un dictionnaire. Puisque le type dictionnaire est un type modifiable, nous pouvons commencer par créer un dictionnaire vide noté {}, puis le remplir petit à petit. >>> traduction = {} >>> print traduction {} >>> traduction["mouse"] = "souris" >>> traduction["keyboard"] = "clavier" {'mouse': 'souris', 'keyboard': 'clavier'} dictionnaire vide insertion d’éléments à l’aide de paires clé-valeur Le dictionnaire est entouré de {}.

Les dictionnaires On peut aussi créer un dictionnaire comme suit : >>> D = {"Duclos" : "Pierre", "Perron" : "Luc"} >>> F, G = {}, {5: "Mauve", 2: "Rouge"} >>> print D, F, G {'Perron': 'Luc', 'Duclos': 'Pierre'} {} {2: 'Rouge', 5: 'Mauve'} L’ordre dans lequel les éléments apparaissent à l’affichage du dictionnaire ne correspond pas nécessairement à celui dans lequel nous les avons insérés. Cela n’a pas d’importance car nous utilisons les clés pour accéder à un élément. >>> Couleur = {1: "Rouge", 2: "Vert", 3: "Bleu"} >>> print Couleur {1: 'Rouge', 2: 'Vert', 3: 'Bleu'} >>> Couleur = {'1': "Rouge", '2': "Vert", '3': "Bleu"} {'1': 'Rouge', '3': 'Bleu', '2': 'Vert'} Illustrons maintenant la variété de types de clés qu’on peut utiliser. >>> D = {1: "un", '1': "valeur_unitaire", 1.1: "valeur_decimale"} >>> print D {'1': 'valeur_unitaire', 1: 'un', 1.1000000000000001: 'valeur_decimale'} >>> D[1.1] 'valeur_decimale'

Les dictionnaires Nous pouvons utiliser en guise de clés n’importe quel type de donnée non modifiable : des entiers, des réels, des chaînes de caractères et même des tuples. >>> sudoku = {} >>> sudoku[(0, 1)] = 9 >>> sudoku[(0, 4)] = 5 >>> sudoku[(0, 7)] = 3 >>> print sudoku {(0, 1): 9, (0, 7): 3, (0, 4): 5} >>> print sudoku[(0,4)] 5 >>> print sudoku[(2,2)] Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> print sudoku[(2,2)] KeyError: (2, 2) Chaque clé dans un dictionnaire est unique. Les dictionnaires permettent tous les opérateurs de type standard mais n’autorisent pas d’opérations telles que la concaténation, la répétition ou l’extraction d’un groupe d’éléments contigus car les dictionnaires ne sont pas des séquences, c’est-à-dire les éléments ne sont pas disposés dans un ordre particulier.

Les dictionnaires Contrairement à une liste, nous ne faisons pas appel à une méthode particulière telle que append() pour ajouter un nouvel élément à un dictionnaire. Il suffit de créer une nouvelle paire clé-valeur. >>> print traduction {'mouse': 'souris', 'keyboard': 'clavier'} >>> traduction["computer"] = "ordinateur" {'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}

Supprimer des éléments d’un dictionnaire ou des dictionnaires entiers Pour enlever un élément à un dictionnaire, on utilise l’instruction del et pour connaître le nombre d’éléments du dictionnaire, on se sert de la fonction len. >>> del traduction["mouse"] >>> print len(traduction) 2 >>> print traduction {'computer': 'ordinateur', 'keyboard': 'clavier'} >>> traduction.pop('computer') 'ordinateur' >>> traduction.clear() {} >>> del traduction Traceback (most recent call last): File "<pyshell#44>", line 1, in <module> print traduction NameError: name 'traduction' is not defined Supprime et retourne l’entrée. Supprime toutes les entrées d’un dictionnaire. Supprime un dictionnaire.

Accès aux valeurs d’un dictionnaire keys() : renvoie la liste des clés utilisées dans le dictionnaire. Cela permet de parcourir un dictionnaire et d’accéder à ses valeurs. >>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'} >>> for cle in dictionnaire.keys(): print 'clé = %s, valeur = %s' % (cle, dictionnaire[cle]) clé = bleu, valeur = blue clé = vert, valeur = green clé = rouge, valeur = red Depuis Python 2.2, ce n’est plus nécessaire d’utiliser la méthode keys(). >>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'} >>> for cle in dictionnaire: print 'clé = %s, valeur = %s' % (cle, dictionnaire[cle]) clé = bleu, valeur = blue clé = vert, valeur = green clé = rouge, valeur = red

Accès aux valeurs d’un dictionnaire On peut aussi accéder isolément aux éléments d’un dictionnaire en spécifiant la clé souhaitée entre crochets : >>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'} >>> print 'clé = %s, valeur = %s' % ('vert', dictionnaire['vert']) clé = vert, valeur = green Si nous essayons d’accéder à une donnée à l’aide d’une clé qui ne figure pas dans le dictionnaire, nous obtenons une erreur. >>> dictionnaire['noir'] Traceback (most recent call last): File "<pyshell#14>", line 1, in <module> dictionnaire['noir'] KeyError: 'noir' On doit donc vérifier si un dictionnaire possède une clé avant de tenter d’accéder à sa valeur. >>> if 'noir' in dictionnaire: dictionnaire['noir'] >>> 'rouge' in dictionnaire True

Accès aux valeurs d’un dictionnaire Voici une autre façon d’utiliser l’opérateur de formatage de chaîne (%) qui ne s’applique qu’aux dictionnaires. >>> print 'La couleur verte se traduit comme suit : %(vert)s.' % dictionnaire La couleur verte se traduit comme suit : green. Comment modifier un dictionnaire ? Vous pouvez mettre à jour un dictionnaire en lui ajoutant une nouvelle entrée ou en modifiant une entrée existante. >>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'} >>> dictionnaire['noir'] = 'black' >>> dictionnaire['bleu'] = 'BLUE' >>> print dictionnaire {'bleu': 'BLUE', 'noir': 'black', 'vert': 'green', 'rouge': 'red'} Lorsqu’on affecte une valeur à une clé qui n’existe pas encore, la clé est créée dans le dictionnaire et la valeur est ajoutée. Mais si la clé existe déjà, alors la valeur existante est remplacée par la nouvelle. >>> dictionnaire = {1: "vert", 1:"VERT"} >>> print dictionnaire {1: 'VERT'}

Fonctions et méthodes permettant de manipuler des dictionnaires. D.values() : renvoie la liste des valeurs utilisées dans le dictionnaire D. D.has_key() : renvoie True (False) si le dictionnaire D (ne) contient (pas) la clé passée en paramètre. D.items() : renvoie une liste équivalente de tuples à partir d’un dictionnaire D. >>> print traduction.keys() ['computer', 'keyboard'] >>> print traduction.values() ['ordinateur', 'clavier'] >>> print traduction.has_key("mouse") False >>> print traduction.items() [('computer', 'ordinateur'), ('keyboard', 'clavier')] D.copy() : effectue une vraie copie d’un dictionnaire D au lieu d’un alias. >>> conversion = traduction.copy() >>> conversion["mouse"] = "souris" >>> print traduction {'computer': 'ordinateur', 'keyboard': 'clavier'} >>> print conversion {'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}

Fonctions et méthodes permettant de manipuler des dictionnaires. type() : renvoie le type de la variable. str() : renvoie une chaîne de caractères représentant le dictionnaire. >>> D = {1: 3.14159, 2: 1.4142} >>> type(D) <type 'dict'> >>> str(D) '{1: 3.1415899999999999, 2: 1.4141999999999999}' dict() : renvoie un dictionnaire issu par exemple d’une séquence où ses éléments doivent être associés deux à deux. Le premier élément constituera une nouvelle clé et le second sa valeur associée. >>> dict([[1,2], [6,7], [3,9]]) {1: 2, 3: 9, 6: 7} >>> dict([(1,2), (6,7), (3,9)]) >>> dict(((1,2), (6,7), (3,9))) clear() : supprime tous les éléments d’un dictionnaire : conversion.clear()

Fonctions et méthodes permettant de manipuler des dictionnaires. D.fromkeys(seq, val) : retourne un nouveau dictionnaire ayant pour clés les éléments de seq avec la même valeur initiale val. >>> Dict = {}.fromkeys("aeiouy", 0) >>> print Dict {'a': 0, 'e': 0, 'i': 0, 'o': 0, 'u': 0, 'y': 0} >>> P = {}.fromkeys(("Marie", "Pierre", "Luc", "Lucie"), "Tremblay") >>> print P {'Marie': 'Tremblay', 'Luc': 'Tremblay', 'Pierre': 'Tremblay', 'Lucie': 'Tremblay'} D.get(cle, val) : En prenant en entrée une clé de recherche cle et la valeur val que nous voulons obtenir en retour si la clé n’existe pas dans le dictionnaire D, la méthode retourne la valeur associée. >>> print sudoku.get((0,4), "néant") 5 >>> print sudoku.get((2, 2), "néant") néant D.pop(cle, val) : Analogue à get(), mais supprime et retourne D[cle] si la clé est présente. Retourne val autrement.

Fonctions et méthodes permettant de manipuler des dictionnaires. Dict.update(Dict1) Ajoute les paires clé-valeur de Dict1 à Dict. Peut être utilisée pour ajouter le contenu d’un dictionnaire à un autre. S’il existe des entrées possédant la même clé, les anciennes valeurs seront remplacées par celles qui sont importées. Celles correspondant à des clés n’existant pas encore seront ajoutées. >>> D = {9807645: "Dubuque", 9678453: "Duluc", 9578967: "Rioux"} >>> E = {9789076: "Roy", 9543212: "Huot"} >>> D.update(E) >>> print D {9789076: 'Roy', 95789: 'Rioux', 95432: 'Huot', 98076: 'Dubuqye', 96784: 'Duluc'} >>> print E {9543212: 'Huot', 9789076: 'Roy'} Dict.setdefault(cle, val) Analogue à get(), mais effectue l’affectation Dict[cle] = val si la clé ne figure pas encore dans le dictionnaire Dict. >>> E = {9789076: "Roy", 9543212: "Huot"} >>> E.setdefault(9312345, "Tremblay") 'Tremblay' >>> print E {9543212: 'Huot', 9789076: 'Roy', 9312345: 'Tremblay'}

Fonctions et méthodes permettant de manipuler des dictionnaires. sorted(Dict) Retourne une liste ordonnée des clés du dictionnaire Dict. >>> D = {"Poire": 2.54, "Peche": 1.29, "Pomme": 2.47, "Prune": 3.56} >>> D.keys() ['Poire', 'Peche', 'Prune', 'Pomme'] >>> sorted(D.keys()) ['Peche', 'Poire', 'Pomme', 'Prune'] >>> for i in sorted(D.keys()): print i, D[i] Peche 1.29 Poire 2.54 Pomme 2.47 Prune 3.56 >>> for i in sorted(D):

Fonctions et méthodes permettant de manipuler des dictionnaires. cmp(D1, D2) : retourne -1, 0 ou 1 comme résultat de la comparaison des dictionnaires D1 et D2. Le traitement se fait dans l’ordre suivant : 1er cas : Comparaison des tailles des dictionnaires. Si les tailles sont différentes, retourne 1 si la taille de D1 est plus grande; -1 autrement. 2ième cas : Comparaison des clés des dictionnaires. Quand les dictionnaires ont la même taille, ce sont leurs clés qui sont comparées dans l’ordre où elles sont fournies par la méthode keys(). Si à une étape quelconque, les clés ne correspondent pas; elles sont alors comparées l’une par rapport à l’autre. 3ième cas : Comparaison des valeurs des dictionnaires. Si les 2 dictionnaires ont même longueur et si toutes leurs clés coïncident, les valeurs associées à chacune de ces clés dans les 2 dictionnaires sont comparées. La première fois que des valeurs différentes associées à une même clé sont rencontrées, ces valeurs sont comparées. La fonction cmp() retourne 1 si la valeur de D1 est supérieure à la valeur dans D2; 0 sinon. 4ième cas : Correspondance exacte. Même longueur, mêmes clés, mêmes valeurs  cmp() retourne 0.

Renvoie 0 si le caractère n’existe pas encore dans le dictionnaire. Exemple # 1 – Construction d’un histogramme à l’aide d’un dictionnaire. >>> texte = "Les dictionnaires constituent un outil très élégant pour construire des histogrammes." >>> caracteres = {} >>> for c in texte: caracteres[c] = caracteres.get(c, 0) + 1 >>> print caracteres {'a': 3, ' ': 10, 'c': 3, 'e': 6, 'd': 2, 'g': 2, 'p': 1, 'i': 7, 'è': 1, 'm': 2, 'L': 1, 'o': 6, 'n': 7, 'é': 2, 's': 8, 'r': 6, 'u': 5, 't': 9, 'h': 1, '.': 1, 'l': 2} >>> caracteres_tries = caracteres.items() >>> caracteres_tries.sort() >>> print caracteres_tries [(' ', 10), ('.', 1), ('L', 1), ('a', 3), ('c', 3), ('d', 2), ('e', 6), ('g', 2), ('h', 1), ('i', 7), ('l', 2), ('m', 2), ('n', 7), ('o', 6), ('p', 1), ('r', 6), ('s', 8), ('t', 9), ('u', 5), ('è', 1), ('é', 2)] Dictionnaire vide Renvoie 0 si le caractère n’existe pas encore dans le dictionnaire. Convertir un dictionnaire en une liste de tuples.

Exemple # 2 – Données d’un cours while True: c = input("Entrez :\t'L' (Lecture des données d'un étudiant)\n" "\t\t'P' (Affichage des données du cours)\n" "\t\t'M' (Moyenne du groupe)\n" "\t\t'S' (Fin du programme).\n") if ( c == 'L'): Matricule, Nom, Prenom, Programme, Note = input("Entrez le matricule, " "les nom et prénom, " "le nom du programme et " "la note sur 100. ") if (Matricule in cours): print "Recommencez car ce matricule existe déjà." else: cours[Matricule] = [Nom, Prenom, Programme, Note] elif (c == 'P'): print "\tMatricule\tNom\tPrenom\tProgramme\tNote" for i in cours: print "\t", i, "\t", cours[i][0], "\t", cours[i][1],cours[i][2],"\t", cours[i][3], "\n" elif (c == 'M'): somme = 0.0 somme += cours[i][3] print "\nLa moyenne du groupe est : ", somme / len(cours), "\n" else: break

Exemple # 3 – Gestion d’un entrepôt de pièces mécaniques. Entrepot = {} while True: c = input("Entrez:\t'R' (Lecture des données d'une pièce)\n" "\t'P' (Affichage des caractéristiques des pièces sous le seuil.)\n" "\t'L' (Livraison d'un nombre d'unités d'une pièce)\n" "\t'C' (Commande d'un nombre d'unités d'une pièce)\n" "\t'S' (Fin du programme).\n") if ( c == 'R'): # Permet d'ajouter une nouvelle pièce mécanique qui n'existe pas # déjà dans l'entrepôt. Numero, Description, Cout_unitaire, Seuil, Nb_unites_disponibles = input( "Entrez le numéro d'identification (entier), " "la description sommaire de la pièce, " "le coût unitaire de la pièce (réel), " "le seuil de ravitaillement (entier) et " "le nombre d'unités de la pièce disponible dans l'entrepôt (entier).\n") if (Numero in Entrepot): print "Recommencez car ce numéro existe déjà." elif (Nb_unites_disponibles < 0 or Seuil < 0): print "Recommencez car les données sont invalides." else: Entrepot[Numero] = [Description, Cout_unitaire, Seuil, Nb_unites_disponibles]

elif (c == 'P'): # Affichage des caractéristiques des pièces mécaniques dont la quantité # est en dessous du seuil de ravitaillement. print "\nNuméro\tDescription\tCoût unitaire\tSeuil\tUnités disponibles" for i in Entrepot: if (Entrepot[i][3] < Entrepot[i][2]): print i, "\t", Entrepot[i][0], "\t", Entrepot[i][1],\ "\t\t", Entrepot[i][2],"\t\t\t", Entrepot[i][3], "\n" elif (c == 'L'): # Met à jour les quantités en stock dans l'entrepôt suite à une livraison # de "Quantite_unites_livrees" unités de la pièce dont le numéro # d’identification est fourni. Numero, Quantite_unites_livrees = input( "Entrez le numéro d'identification (entier), " "la quantité d'unités livrées (entier).") if (Numero not in Entrepot): print "Recommencez: ce numéro n'existe pas." elif (Quantite_unites_livrees <= 0): print "Recommencez car les données sont invalides." else: Entrepot[Numero][3] += Quantite_unites_livrees

# Met à jour les quantités en stock dans l'entrepôt suite à une elif (c == 'C'): # Met à jour les quantités en stock dans l'entrepôt suite à une # commande de "Quantite_commandee" unités de la pièce dont le # numéro d’identification est fourni. Numero, Quantite_commandee = input( "Entrez le numéro d'identification (entier), " "la quantité commandée (entier).") if (Numero not in Entrepot): print "Recommencez: ce numéro n'existe pas." elif (Quantite_commandee <= 0 or Quantite_commandee > Entrepot[Numero][3]): print "Recommencez car les données sont invalides." else: Entrepot[Numero][3] -= Quantite_commandee else: break Énoncé : Un entrepôt renferme des pièces mécaniques dont les caractéristiques sont : un numéro d’identification unique, une description sommaire de la pièce, un coût unitaire, un seuil de ravitaillement et le nombre d’unités de la pièce disponibles dans l’entrepôt. Ce programme permet d’ajouter de nouvelles pièces, de livrer un nombre d’unités d’une pièce, de gérer une commande d’un nombre d’unités d’une pièce et d’afficher les caractéristiques des pièces dont la quantité est en dessous du seuil de ravitaillement.