Dictionnaire, en python dict

A l’instar des list, les dict (pour dictionnaire) sont des conteneurs dynamiques.
Mais, alors que l’accès aux éléments d’une liste se fait grâce à un indice positionnel, les dictionnaires stockent en fait des associations entre objets python.
L’objet équivalent à l’indice est appelée la clef, et l’objet associé est appelée la valeur.

Avant d’expliciter la syntaxe donnons un exemple d’utilisation.

>>> mon_dico = dict()
>>> mon_dico
{}
>>> mon_dico["premiere_clef"] = "premiere_valeur"
>>> mon_dico
{'premiere_clef': 'premiere_valeur'}
>>> mon_dico[1] = [1, 2, 3]
>>> mon_dico[(1, 2)] = "alpha"
>>> mon_dico
{'premiere_clef': 'premiere_valeur', 1: [1, 2, 3], (1, 2): 'alpha'}
>>> mon_dico[1]
[1, 2, 3]
>>> mon_dico[(1, 2)]
'alpha'

On voit que l’on a utilisé comme clefs des objets de type str, int et tuple. On indiquera à la fin de la leçon la règle pour qu’un objet puisse être utiliser comme clef.

Création

On peut créer des dictionnaires de trois façons distinctes (c’était déjà le cas des listes).

REMARQUE en fait le constructeur dict accepte aussi de faire certaines conversions.

>>> dict(a=1, b=2, c=3)
{'a': 1, 'b': 2, 'c': 3}
>>> dict([("a", 1), ("b", 2), ("c", 2)])
{'a': 1, 'b': 2, 'c': 2}

Manipulation

>>> mon_dico = dict()
>>> mon_dico["clef"]

KeyError:
clef

On a alors deux solutions pour résoudre le problème:

  1. on peut d’abord tester si la clef est bien dans le dictionnaire avec l’opérateur in:
>>> mon_dico = { "c": "v"}
>>> if "c" in mon_dico:
...     print(f"clef: {'c'}, valeur: {mon_dico['c']}")
...
clef: c, valeur: v
>>> if "d" in mon_dico:
...     print(f"clef: {'d'}, valeur: {mon_dico['d']}")
... else:
...     print("La clef n'existe pas")
...
La clef n'existe pas

REMARQUE l’opérateur in permet aussi de tester l’appartenance pour les list et les tuples.

  1. On peut fournir une valeur par défaut à utiliser si jamais la clef n’existe pas via la méthode get

    >>> mon_dico = {"c": "v"}
>>> print(mon_dico.get("c", "PAS DE TELLE CLEF"))
v
>>> print(mon_dico.get("d", "PAS DE TELLE CLEF"))
PAS DE TELLE CLEF

REMARQUE une syntaxe un peu barbare au premier abord mais très utile dans certaines situations permet de faire sauter les parenthèses d’un dictionnaire en précédant le nom du dictionnaire par **. Pour les list/tuples on n’utilise que *.

.>>> def ma_fonction(arg1, arg2, arg3):
...     print(f"arg1: {arg1}")
...     print(f"arg2: {arg2}")
...     print(f"arg3: {arg3}")
...
>>> liste = [1, 2, 3]
>>> ma_fonction(*liste)
arg1: 1
arg2: 2
arg3: 3
>>> dico = dict(arg2=2, arg3=3, arg1=1)
>>> dico
{'arg2': 2, 'arg3': 3, 'arg1': 1}
>>> ma_fonction(**dico)
arg1: 1
arg2: 2
arg3: 3

L’utilisation de list/tuple correspond à l’appel par argument ordonnés alors que l’utilisation de dict correspond à l’appel par arguments nommés.

ATTENTION les dict sont généralement appelées tables de hachages. Pour que des objets soit utilisables comme clefs il faut qu’elles soient hachables. Sans rentrer dans des détails techniques (consulter la fiche wikipédia en lien précédent) on partira du principe qu’en python cela sous entend que l’objet ne doit pas être mutable. Ainsi si on essaye d’utiliser une list:

>>> dico = dict()
>>> dico[[1, 2]] = "test"

------------------------------------------------------------------------------------------
<stdin> 1 <module>
1

TypeError:
unhashable type: 'list'

Exercices

  1. Codez une fonction calcule_frequence prenant en entrée texte: str et retournant le dictionaire contenant la fréquences des caractères dans le texte.
  2. Codez une fonction affiche_notes prenant en entrée classe: dict[str: list[int]] et renvoyant en sortie une chaine résumant les notes de la classe suivant l’exemple suivant.
>>> classe = {"Bob": [5, 10, 15], "Alice": [10, 15, 20]}
>>> print(affiche_notes(classe))

Alice : 15.0 de moyenne
    Notes : 10, 15, 20
    Bob : 10.0 de moyenne
        Notes : 5, 10, 15

>>> affiche_notes(classe)
'\nAlice : 15.0 de moyenne\n    Notes : 10, 15, 20\nBob : 10.0 de moyenne\n    Notes : 5, 10, 15\n'

Pour aller plus loin

Pour voir l’ensemble des méthodes disponibles pour un dict

>>> dir(dict)

Puis si on veut par exemple voir la documentation sur la méthode copy

>>> help(dict.copy)

Pour l’appartenance

>>> help("in")

Corrections

Voir le fichier joint.