Les dictionnaires
Une vidéo de présentation des dictionnaires…
Comme on l’a vu, Python dispose d’un grand nombre de séquences. Tous les langages modernes disposent également d’un ou plusieurs tableaux associatifs. En Python il prend le nom de dictionnaire. Il se définit à partir des opérateurs {
et }
ou du constructeur de la classe dict
. Le dictionnaire est un container mutable.
Structure
Un dictionnaire est constitué d’un ensemble de paires clé:valeur
. La clé doit être un élément immutable. Un dict
conserve l’ordre dans lequel les paires clé:valeur
ont été insérées.
>>> d = dict()
>>> type(d)
<class 'dict'>
On ajoute des éléments à un dict
avec l’opérateur d’indexation [ ]
:
>>> d['Italy'] = 'Rome'
>>> d['France'] = 'Paris'
>>> d['Spain'] = 'Madrid'
>>> d
{'Italy': 'Rome', 'France': 'Paris', 'Spain': 'Madrid'}
Un dict
possède un ensemble de méthodes:
>>> dir(d)
[..., 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
En particulier, la méthode keys()
retourne une vue des clés du dictionnaire:
>>> d.keys()
dict_keys(['Italy', 'France', 'Spain'])
En particulier, la méthode values()
retourne une vue des valeurs associées:
>>> d.values()
dict_values(['Rome', 'Paris', 'Madrid'])
Les vues sont des objets itérables:
>>> for key in d.keys():
... print(key)
...
Italy
France
Spain
On peut également créer un dict
à partir d’une sequence de paires clé:valeur
.
Cette séquence peut être une list
de tuple
:
>>> d = dict([('Italy','Rome'), ('Spain','Madrid'), ('France','Paris')])
>>> d
{'Spain': 'Madrid', 'Italy': 'Rome', 'France': 'Paris'}
>>> d = dict((('Italy','Rome'), ('Spain','Madrid'), ('France','Paris')))
>>> d
{'Spain': 'Madrid', 'Italy': 'Rome', 'France': 'Paris'}
Accès aux éléments
Si d
est un dict
, on accède à ses éléments avec la syntaxe d[key]
. Si l’élément existe, il est retourné:
>>> d['Italy']
'Rome'
S’il n’existe pas, une erreur se produit:
>>> d['Portugal']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Portugal'
get()
est une méthode plus sûre. Si l’élément existe, il est retourné. S’il n’existe pas, une valeur par défaut est utilisée. Si elle n’est pas précisée, la valeur par défaut est None
:
>>> d.get('Portugal')
>>> d.get('Portugal', 'key not in dict')
'key not in dict'
Modification de la structure d’un dictionnaire
Le dict
étant un élément mutable, on peut ajouter des éléments avec la syntaxe d[key] = value
:
>>> d['Portugal'] = 'Lisbon'
>>> d
{'Portugal': 'Lisbon', 'Italy': 'Rome', 'France': 'Paris', 'Spain': 'Madrid'}
On peut en retirer avec la syntaxe del d[key]
:
>>> del d['Spain']
>>> d
{'Portugal': 'Lisbon', 'Italy': 'Rome', 'France': 'Paris'}
On peut également utiliser la méthode update()
qui prend en argument un second dictionnaire. Le dictionnaire sur lequel la méthode est appelée est modifié avec les paires clé:valeur
qu’il contient:
>>> d.update({'Germany':'Berlin', 'United Kingdom':'London'})
>>> d
{'Italy': 'Rome', 'France': 'Paris', 'Portugal': 'Lisbon', 'Germany': 'Berlin', 'United Kingdom': 'London'}
A expérimenter…
Ajouter quelques paires clé-valeur au dictionnaire ci dessus avec l’opérateur d’indexation [ ]
. Puis de façon groupée à partir d’un second dictionnaire.
Itérer sur le dictionnaire ainsi créé en utilisant le Formatage des chaines de caractères pour produire un affichage structuré de l’association capitale-pays.
Appartenance
Comme les sequences le dict
utilise l’opérateur in
pour tester l’appartenance d’une clé ou d’une valeur:
>>> 'Italy' in d.keys()
True
>>> 'Rome' in d.values()
True
Tester l’appartenance au dictionnaire lui même fonctionne pour les clés:
>>> 'Italy' in d
True
mais pas pour les valeurs:
>>> 'Rome' in d
False
Itérer sur un dictionnaire
La méthode keys()
retournant un iterable, on peut utiliser l’opérateur in
pour itérer sur les clés:
>>> for k in d.keys():
... print(k)
...
United Kingdom
Italy
Germany
Portugal
France
On a constaté plus haut que la méthode keys()
retourne une vue des clés du dictionnaire. Cette vue est dynamique, c’est à dire qu’elle évolue tout au long de la vie du dictionnaire:
>>> keys = d.keys()
>>> keys
dict_keys(['United Kingdom', 'Italy', 'Germany', 'Portugal', 'France'])
>>> del d['Italy']
>>> keys
dict_keys(['United Kingdom', 'Germany', 'Portugal', 'France'])
Note
Un dictionnaire n’est pas conçu pour itérer sur les valeurs.
Au delà des clés et des valeurs, on peut récupérer la paire clé-valeur
dans un tuple
en une seule opération avec la méthode items()
:
>>> for k,v in d.items():
... print(k,v)
...
United Kingdom London
Germany Berlin
Portugal Lisbon
France Paris
Autres méthodes
Pour une connaissance approfondie des dictionnaires, on consultera la liste des méthodes associées.
Les “dict comprehension”
Comme pour les list
et les set
, il existe une syntaxe compacte pour construire un dict
: les dict comprehension
. L’exemple ci dessous donne le code ASCII des caractères de ponctuation:
>>> import string
>>> { char:ord(char) for char in string.punctuation}
{']': 93, '&': 38, '~': 126, ... , '/': 47}
La sortie a été tronquée pour l’affichage
Implémentation de switch
Comme évoqué au chapître Contrôle de l’exécution d’un programme, Python ne dispose pas en standard de l’instruction switch
mais une implémentation élégante et compacte est possible avec un dictionnaire:
>>> d = {'a':'Choix A', 'b':'Choix B', 'c':'Choix C'}
>>> choix = 'b'
>>> print(d[choix])
L’intérêt est de grouper les différents cas sur une seule ligne. Comme en Python tout est objet, les valeurs du dictionnaire peuvent être des fonctions.
A titre d’exemple, l’utilisation de switch
en Java:
1public class SwitchDemo {
2 public static void main(String[] args) {
3 String choix = 'b';
4 String res;
5 switch (choix) {
6 case 'a': res = "Choix A";
7 break;
8 case 'b': res = "Choix B";
9 break;
10 case 'c': res = "Choix C";
11 break;
12 }
13 System.out.println(res);
14 }
15}
Ce qu’il faut retenir
Un dictionnaire se délimite avec
[
et]
Un dictionnaire se délimite avec
(
et)
Un dictionnaire se délimite avec
{
et}
Les clés d’un dictionnaire sont obligatoirement immutable
Les clés d’un dictionnaire sont toutes de même type
On peut utiliser des chaines de caractères comme clés d’un dictionnaire
On peut utiliser des entiers comme clés d’un dictionnaire
On peut utiliser des tuples comme clés d’un dictionnaire
On peut utiliser des listes comme clés d’un dictionnaire
On peut utiliser des sets comme clés d’un dictionnaire
Les valeurs d’un dictionnaire sont toutes de même type
Les valeurs d’un dictionnaire sont obligatoirement immutable
Un dictionnaire est mutable
Un dictionnaire est une collection ordonnée
Une fois créée, la taille d’un dictionnaire est figée
L’opérateur d’indexation permet d’insérer un élément dans un dictionnaire
L’opérateur d’indexation permet d’insérer un élément au début d’un dictionnaire
L’opérateur d’indexation permet d’insérer un élément à la fin d’un dictionnaire
permet de supprimer un élément d’un dictionnaire
Le constructeur d’un dictionnaire peut prendre en paramètre une séquence
Cette séquence est une séquence de clés
Cette séquence est une séquence de valeurs
Cette séquence est une séquence de paires
clé:valeur
La méthode permet de modifier un dictionnaire avec un autre dictionnaire
Sur un dictionnaire, l’opérateur d’appartenance
in
fonctionne pour les clésSur un dictionnaire, l’opérateur d’appartenance
in
fonctionne pour les valeursOn peut parcourir un dictionnaire en itérant sur ses clés
On peut parcourir un dictionnaire en itérant sur ses valeurs
On peut construire des dictionnaires imbriqués
Un est une façon concise de construire un dictionnaire