Les dictionnaires

Comme les listes, les dictionnaires sont des conteneurs. C’est-à-dire qu’ils contiennent d’autres valeurs auxquelles on peut accéder avec l’opérateur d’indexation [].

Mais plutôt qu’associer une valeur à un index, ils vont l’associer à une clé quelconque, par exemple une chaîne de caractères. Il s’agit donc d’un ensemble de couples clé-valeur.

Un dictionnaire se définit avec des accolades, entre lesquelles les couples sont séparés par des virgules. Un couple clé-valeur est de la forme clé: valeur.

Voilà à quoi pourrait ressembler le répertoire téléphonique donné en introduction :

phonebook = {'Alice': '0633432380', 'Bob': '0663621029', 'Alex': '0714381809'}

C’est déjà plus clair à écrire, mais là où ça devient intéressant c’est pour l’accès aux éléments. On retrouve en effet l’opérateur [], mais on va pouvoir lui préciser une clé de notre dictionnaire plutôt qu’un index.

>>> phonebook['Alex']
'0714381809'

Il suffit de connaître le nom pour accéder au numéro, pas besoin de parcourir tout le répertoire. On comprend donc l’analogie avec le dictionnaire, qui permet d’associer des définitions à des mots, et de retrouver la définition à partir du mot.

Les dictionnaires sont des objets modifiables, on retrouve donc l’opérateur d’indexation en lecture et en écriture.

>>> phonebook['Alice']
'0633432380'
>>> phonebook['Bob'] = '0712800331'
>>> del phonebook['Alex']
>>> phonebook
{'Alice': '0633432380', 'Bob': '0712800331'}

Par contre pas de slicing ici, cela n’a pas de sens sur des clés de dictionnaire.

Une clé non trouvée dans le dictionnaire provoque une erreur.

>>> phonebook['Mehdi']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Mehdi'

Les dictionnaires sont sensibles à la casse, c’est-à-dire que les lettres majuscules sont traitées différemment des minuscules. 'Alice' et 'alice' sont alors deux clés distinctes.

>>> phonebook['alice'] = '0729570663'
>>> phonebook
{'Alice': '0633432380', 'Bob': '0712800331', 'alice': '0729570663'}

On retrouve aussi l’opérateur d’appartenance (in), qui fonctionne sur les clés et non sur les valeurs.

>>> 'Bob' in phonebook
True
>>> '0633432380' in phonebook
False

Et on peut connaître la taille d’un dictionnaire en appelant la fonction len.

>>> len(phonebook)
3

Comme tout objet, il est possible de tester l’égalité entre deux dictionnaires avec l’opérateur ==, et la différence avec !=. Deux dictionnaires sont considérés comme égaux s’ils contiennent les mêmes éléments, avec les mêmes valeurs pour les mêmes clés.

>>> {'a': 1} == {'a': 1}
True
>>> {'a': 0} == {'b': 0}
False
>>> {'a': 0} != {'a': 0, 'b': 1}
True

Cela est vrai quel que soit l’ordre des éléments dans le dictionnaire.

>>> {'a': 0, 'b': 1} == {'b': 1, 'a': 0}
True
>>> {'a': 0, 'b': 1} != {'b': 1, 'a': 0, 'c': 2}
True

Méthodes principales

Une première méthode intéressante est la méthode get. Elle agit comme l’opérateur [] mais sans produire d’erreur si la clé n’est pas trouvée.

>>> phonebook.get('Mehdi')
>>> print(phonebook.get('Mehdi'))
None

Comme on le voit, la valeur renvoyée si la clé n’est pas trouvée est None. Il est possible de renvoyer une autre valeur en la précisant comme second argument à get.

>>> phonebook.get('Mehdi', 'xxx')
'xxx'

Ensuite on va surtout trouver des méthodes pour modifier le dictionnaire, comme on en trouvait sur les listes.

La méthode pop est d’ailleurs équivalente à celle des listes, elle supprime une clé du dictionnaire et renvoie la valeur associée.

>>> phonebook.pop('Alice')
'0633432380'
>>> phonebook.pop('alice')
'0729570663'

L’appel produit une erreur si la clé n’est pas trouvée, mais il est là encore possible de donner une valeur par défaut en deuxième argument.

>>> phonebook.pop('Mehdi')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Mehdi'
>>> phonebook.pop('Mehdi', 'xxx')
'xxx'

La méthode update permet d’étendre le dictionnaire avec les données d’un autre dictionnaire.

>>> phonebook.update({'Julie': '0619096810', 'Mehdi': '0762253973'})
>>> phonebook
{'Bob': '0712800331', 'Julie': '0619096810', 'Mehdi': '0762253973'}

Si une clé existe déjà dans le dictionnaire actuel, sa valeur est remplacée par la nouvelle qui est reçue.

>>> phonebook.update({'Julie': '0734593960'})
>>> phonebook
{'Bob': '0712800331', 'Julie': '0734593960', 'Mehdi': '0762253973'}

La méthode clear sert à vider complètement un dictionnaire.

>>> phonebook.clear()
>>> phonebook
{}

{} représente donc un dictionnaire vide.

Enfin, setdefault est un peu le pendant de get mais en écriture : elle va insérer une valeur dans le dictionnaire seulement si la clé n’est pas déjà présente.
La méthode renvoie la valeur associée à cette clé dans le dictionnaire, donc soit celle qui vient d’être ajoutée soit celle qui était déjà présente.

>>> phonebook.setdefault('Julie', '0619096810')
'0619096810'
>>> phonebook.setdefault('Julie', '0734593960')
'0619096810'
>>> phonebook
{'Julie': '0619096810'}

Conversions

On peut convertir une liste de couples clé/valeur en un dictionnaire, en appelant dict comme une fonction.

Par exemple avec notre répertoire téléphonique défini en introduction :

>>> phonebook = [['Alice', '0633432380'], ['Bob', '0663621029'], ['Alex', '0714381809']]
>>> dict(phonebook)
{'Alice': '0633432380', 'Bob': '0663621029', 'Alex': '0714381809'}

L’appel à dict sur un dictionnaire existant permet aussi d’en créer une copie.

>>> phonebook = {'Mehdi': '0762253973'}
>>> mybook = dict(phonebook)
>>> mybook['Julie'] = '0734593960'
>>> mybook
{'Mehdi': '0762253973', 'Julie': '0734593960'}
>>> phonebook
{'Mehdi': '0762253973'}

Enfin, une autre utilité de l’appel à dict est de pouvoir construire un dictionnaire à partir d’arguments nommés. Les noms des arguments deviennent ainsi les clés du dictionnaire.

>>> dict(Bob='0712800331', Julie='0734593960', Mehdi='0762253973')
{'Bob': '0712800331', 'Julie': '0734593960', 'Mehdi': '0762253973'}

Un autre cas d’utilisation des dictionnaires est celui d’agréger dans un même objet plusieurs valeurs liées les unes aux autres, plutôt que dans des variables différentes. Pensez par exemple à la représentation des monstres dans notre TP : on a un nom d’un côté, un nombre de PV de l’autre et aussi une liste d’attaques.

À la place, on pourrait utiliser un dictionnaire par monstre, en y faisant figurer toutes ses données.

{
    'nom': 'Pythachu',
    'PV': 50,
    'attaques': ['tonnerre', 'charge'],
}

En effet, tous les types de données sont acceptés en tant que valeurs, et toutes les valeurs n’ont pas besoin d’être du même type.

Mais on peut faire encore mieux. En usant de listes et de dictionnaires, on construit facilement des structures arborescentes pour représenter toutes nos données.

monstres = {
    'Pythachu': {
        'type': 'foudre',
        'description': 'Petit rat surchargé.',
        'attaques': ['tonnerre', 'charge'],
    },
    'Pythard': {
        'type': 'aquatique',
        'description': "Tétard qui a cru qu'il était tôt.",
        'attaques': ['jet-de-flotte', 'charge'],
    },
    'Ponytha': {
        'type': 'flamme',
        'description': 'Cheval enflammé.',
        'attaques': ['brûlure', 'charge'],
    },
}

attaques = {
    'charge': {'degats': 20},
    'tonnerre': {'degats': 50},
    'jet-de-flotte': {'degats': 40},
    'brûlure': {'degats': 40},
}

joueurs = [
    {
        'nom': 'Joueur 1',
        'monstre': 'Pythachu',
        'PV': 100,
    },
    {
        'nom': 'Joueur 2',
        'monstre': 'Ponytha',
        'PV': 120,
    },
]

Ainsi, on représente dans des variables différentes la structure de nos données. Pour avoir d’un côté la définition des monstres et des attaques, et de l’autre les monstres en jeu.

>>> print(joueurs[0]['nom'], ':', joueurs[0]['monstre'])
Joueur 1 : Pythachu
>>> print('Attaques :', monstres[joueurs[0]['monstre']]['attaques'])
Attaques : ['tonnerre', 'charge']
>>> print('Dégâts de tonnerre :', attaques['tonnerre']['degats'])
Dégâts de tonnerre : 50

Jusqu’ici, je n’ai présenté que des chaînes de caractères comme clés de dictionnaire, par souci de simplicité.

Mais ce ne sont pas les seuls types de clés possibles, les booléens ou les nombres sont aussi des clés valides.

choices = {
    True: 'OK',
    False: 'KO',
}

diviseurs = {
    4: [1, 2],
    6: [1, 2, 3],
    8: [1, 2, 4],
    9: [1, 3],
    10: [1, 2, 5],
}

Qui s’utilisent de la même manière lors de l’indexation.

>>> choices[True]
'OK'
>>> choices[False] = 'erreur'
>>> diviseurs[8]
[1, 2, 4]
>>> diviseurs.get(5, [1])
[1]

En revanche, tout type de données n’est pas accepté comme clé de dictionnaire. Vous avez dû vous en rendre compte si vous avez essayé d’y placer une liste ou un dictionnaire.

>>> {[]: 0}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Nous reviendrons plus tard sur cette erreur et ce qu’elle signifie, mais retenez pour le moment que dans les types que nous connaissons seuls les non-modifiables peuvent être utilisés en tant que clés.

Les valeurs modifiables telles que les listes ou les dictionnaires ne peuvent pas être utilisées en tant que clés, car comment retrouverait-on la valeur associée si la clé est mise à jour ?