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'}

ou un tuple de tuple:

>>> 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 chapitre 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és

  • Sur un dictionnaire, l’opérateur d’appartenance in fonctionne pour les valeurs

  • On 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