Les dictionnaires sont des structures mutables, non ordonnées, formées d’enregistrements du type clé :valeur
Le seul moyen d’accéder à une valeur particulière est par l’intermédiaire de sa clé.
Les dictionnaires peuvent être formés :
-
en évaluant l’expression
dict()ou{}. On obtient le dictionnaire vide - En délimitant par { et } une séquence de paires
clé:valeur:{clé1:val1, clé2:val2, …, clén:valn}. - En évaluant par exemple :
dict([[clé1,val1],[clé2,val2],…,[clén,valn]]). -
en ajoutant des paires clé
:valeur à un dictionnaire existant. On a ici une différence essentielle avec les listes, pour lesquelles il est seulement possible de modifier un élément existant ou d’ajouter un élément supplémentaire à lafinde la liste avec la méthodeappend -
en “compréhension”, par exemple
D = {x:x*2 for x in range(10)}
Voici quelques méthodes applicables à un objet dic de type dictionnaire. On note ici cle une clé et val une valeur :
len(dic) |
renvoie la longueur du dictionnaire (nombres de clés) |
dic[cle] |
renvoie la valeur associée à la clé (lève KeyError si la clé est absente) |
dic[cle] = val |
crée (ou modifie) une paire clé/valeur |
del dic[cle] |
efface une paire clé/valeur |
cle in dic |
renvoie True si la clé est présente dans le dictionnaire, False sinon |
cle not in dic |
renvoie True si la clé est absente du dictionnaire, False sinon |
dic.clear() |
efface le contenu du dictionnaire |
dic.copy() |
renvoie une copie du dictionnaire, indépendante de l’original |
dic.get(cle)dic .get(cle,def ) |
renvoie la valeur associée à la clé, et renvoie None si la clé est absente.renvoie la valeur associée à la clé, et la valeur de def si la clé est absente |
dic.items() |
renvoie un itérable pour décrire les couples (clé,valeur) dans une boucle for |
dic.keys() |
renvoie un itérable pour décrire les clés du dictionnaire dans une boucle for |
dic.pop(cle)dic .pop(cle,def ) |
renvoie la valeur, et supprime la paire clé/valeur (KeyError si clé absente)renvoie la valeur, et supprime la paire clé/valeur (évalue def si clé absente) |
dic.popitem() |
Renvoie une paire arbitraire (clé,valeur) et la supprime de dic (KeyError si dic vide) |
dic.setdefaut(cle)dic .setdefaut(cle,def ) |
renvoie la valeur si la clé est présente, sinon crée le couple cle:Nonerenvoie la valeur si la clé est présente, sinon crée le couple cle :def |
dic.update(dic2) |
fusionne le dictionnaire dic2 sur le dictionnaire dic (remplace les valeurs si clés homo- nymes). Ici dic2 peut aussi être une liste de listes [cle,valeur] |
dic.values() |
renvoie un itérable pour décrire les valeurs du dictionnaire dans une boucle for |
Les dictionnaires sont optimisés pour un accès aux valeurs par un “hachage” rapide sur les clés.
L’utilisateur n’a aucun moyen de savoir dans quel ordre les couples clés/valeurs sont placés dans le dictionnaire (et cette question est en fait sans importance).
À ce titre, les dictionnaires ne sont pas des séquences (ils ne peuvent pas être parcourus par un indice de position). Ils sont cependant considérés comme des objets “itérables” (on peut donc les parcourir).
Si les valeurs placées dans un dictionnaire peuvent être quelconques (et par exemple être elles-mêmes des dictionnaires), les clés utilisées pour accéder à ces valeurs doivent être d’un type non mutable (entiers, chaînes, par exemple).
Dans un dictionnaire donné, les clés doivent être uniques, mais elles ne doivent pas nécessairement être du même type.
Voici un exemple (très simple !) de dictionnaire (les clés sont des noms, les valeurs des âges…) :
|
1 2 3 4 5 6 7 8 9 10 11 |
>>> ages = {'Paul':41, 'Léon':25, 'Jeanne':134} # crée un dictionnaires de trois entrées >>> ages # l'ordre affiché est non prévisible {'Paul': 41, 'Jeanne': 134, 'Léon': 25} >>> 'Paul' in ages, 'Jean' in ages # teste la présence de deux clés (True, False) >>> ages['Jean'] # demander l'âge de Jean conduit à une erreur <...> KeyError: 'Jean' >>> ages.get('Jean',-1) # ici pas d'erreur, mais une valeur par défaut -1 >>> ages['Marc'] = 33 # crée un nouvel enregistrement >>> del ages['Paul'] # supprime un enregistrement |
On continue à la suite de l’exemple précédent…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
>>> for elt in ages: print(elt) # itérer un dictionnaire, c'est itérer les clés Marc Jeanne Léo >>> for (n,a) in ages.items(): # voici comment itérer sur les paires (clé,valeur) print('Son prénom est {} et son âge est {} ans'.format(n,a)) Son prénom est Marc et son âge est 33 ans Son prénom est Jeanne et son âge est 134 ans Son prénom est Léon et son âge est 25 ans >>> list(ages) # la conversion ne donne ici que les clés ['Marc', 'Jeanne', 'Léon'] >>> list(ages.keys()) # autre façon d'obtenir la liste des clés ['Marc', 'Jeanne', 'Léon'] >>> list(ages.values()) # la liste des valeurs [33, 134, 25] >>> max(ages.values()) # la valeur maximum 134 >>> [(n,a) for n,a in ages.items()] # voici la liste des enregistrements [('Marc', 33), ('Jeanne', 134), ('Léon', 25)] |