2.9. Dictionnaires

Un dictionnaire est une correspondance entre des clés et des valeurs. Chaque clé est recherchée directement ; le dictionnaire se souvient de la dernière valeur associée à cette clé.

2.9.1. Créer des dictionnaires

Utilisez des accolades avec des paires key: value, ou le constructeur dict :

empty   = {}
person  = {"name": "OpenMV", "id": 42}
counts  = dict(a=1, b=2, c=3)            # keyword form
pairs   = dict([("x", 1), ("y", 2)])     # from a list of pairs

Les valeurs peuvent être de n’importe quel type – chaînes de caractères, nombres, listes, voire d’autres dictionnaires :

config = {
    "name":  "OpenMV",
    "id":    42,
    "width": 320,
    "tags":  ["red", "round"],
}

Chaque clé d’un dictionnaire correspond à exactement une valeur.

2.9.2. Accès et appartenance

L’indexation avec [] récupère la valeur associée à une clé. Une clé absente déclenche une KeyError :

>>> person = {"name": "OpenMV", "id": 42}
>>> person["name"]
'OpenMV'
>>> person["missing"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'missing'

Pour une recherche plus tolérante, utilisez dict.get(). Elle renvoie None pour une clé absente, ou une valeur que vous passez en second argument :

>>> person.get("name")
'OpenMV'
>>> person.get("missing")            # returns None
>>> person.get("missing", "n/a")
'n/a'

Le mot-clé in teste l’appartenance d’une clé – pas d’une valeur :

>>> "name" in person
True
>>> "OpenMV" in person
False

2.9.3. Ajouter, mettre à jour et supprimer

Une affectation à d[key] ajoute l’entrée si la clé est nouvelle et l’écrase si elle existe déjà :

>>> person["seen"] = 1
>>> person["seen"] = 2               # overwrites
>>> person
{'name': 'OpenMV', 'id': 42, 'seen': 2}

La suppression prend plusieurs formes :

• del d[key] – supprime une entrée ; déclenche une KeyError si la clé est absente.

• dict.pop() – supprime et renvoie la valeur ; une valeur par défaut optionnelle vous évite l’exception.

• dict.clear() – supprime toutes les entrées.

dict.update() fusionne un autre dictionnaire (ou une liste de paires (key, value)) dans le destinataire, en écrasant toutes les clés correspondantes :

>>> person.update({"id": 100, "owner": "alice"})
>>> person
{'name': 'OpenMV', 'id': 100, 'seen': 2, 'owner': 'alice'}

2.9.4. Itérer

Itérer directement sur un dictionnaire produit ses clés, dans l’ordre d’insertion :

for k in person:
    print(k)

Trois vues offrent un accès explicite :

• dict.keys() – les clés (identique à l’itération sur le dictionnaire).

• dict.values() – les valeurs.

• dict.items() – des tuples (key, value), parfaits pour le dépaquetage dans une boucle.

for key, value in person.items():
    print(key, "=", value)

2.9.5. Ce qui peut servir de clé

Les clés d’un dictionnaire doivent être hachables – leur valeur ne peut pas changer au cours de leur existence. Les types hachables courants sont :

• int, float, bool

• str, bytes

• tuple (lorsque chaque élément qu’il contient est lui-même hachable)

• None

Les types mutables comme list, dict et bytearray ne peuvent pas servir de clés ; en utiliser un déclenche une TypeError. Les tuples de valeurs immuables sont la manière standard d’indexer un dictionnaire par un identifiant composite, tel qu’une coordonnée de grille 2D :

>>> grid = {}
>>> grid[(0, 0)] = "start"
>>> grid[(5, 7)] = "end"

2.9.6. Longueur

len() renvoie le nombre d’entrées :

>>> len(person)
4