Un dictionnaire (dict) en Python est une structure de données qui associe des clés hachables à des valeurs, et que l'on connaît dans d'autres langages de programmation sous les noms de table de hachage redimensionnable, de hashmap ou de tableau associatif.
Les dictionnaires sont le seul type de correspondance intégré à Python.
Keys doivent être hachables et uniques au sein du dictionnaire.
Les types de clés peuvent inclure des numbers, des str ou des tuples (de valeurs immuables).
Elles ne peuvent pas contenir de structures de données mutables telles que des lists, des dict ou des set.
Depuis Python 3.7, l'ordre des clés d'un dict correspond à l'ordre d'insertion des entrées.
Les values peuvent être de n'importe quel type ou structure de données.
Les valeurs peuvent aussi s'imbriquer arbitrairement, et donc contenir des listes de listes, des sous-dictionnaires et d'autres structures de données personnalisées ou composites.
Étant donné une key, un dictionnaire peut retrouver une value en temps constant (en moyenne), indépendamment du nombre d'entrées.
Comparé à la recherche d'une valeur dans une list ou un array (sans connaître la position de l'index), un dict utilise nettement plus de mémoire, mais la récupération est très rapide.
Les dictionnaires sont particulièrement utiles lorsque la collection d'éléments est volumineuse et doit être consultée et mise à jour fréquemment.
Construction d'un dictionnaire
On peut créer un dictionnaire de bien des façons.
Les deux plus directes consistent à utiliser le constructeur dict() ou à déclarer un littéral dict.
Le constructeur de la classe dict()
dict() (le constructeur de la classe dictionnaire) peut s'utiliser avec n'importe quel itérable de paires key, value, ou avec une série d'arguments <name>=<value> :
#Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),('speed', 23),('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}
#Using key=value arguments.
>>> bear = dict(name="Black Bear", speed=40, land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}
Les littéraux de dictionnaire
Un dict peut aussi s'écrire directement sous forme de littéral de dictionnaire, à l'aide d'accolades ({}) encadrant des paires key : value :
>>> whale = {"name": "Blue Whale", "speed": 35, "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}
Accéder aux valeurs d'un dictionnaire
On accède à une entrée d'un dictionnaire à l'aide d'une clé entre crochets ([]).
Si une key n'existe pas dans le dict, une KeyError est levée :
>>> bear["speed"]
40
>>> bear["color"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'color'
Accéder à une entrée via la méthode .get(<key>, <default value>) permet d'éviter la KeyError :
>>> bear.get("color", 'not found')
'not found'
Modifier ou ajouter des valeurs dans un dictionnaire
On peut modifier la value d'une entrée en affectant à sa clé :
#Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}
>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}
De nouvelles paires key:value peuvent être ajoutées de la même manière :
# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}
>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}
Supprimer (pop) des entrées d'un dictionnaire
On peut utiliser la méthode .pop(<key>) pour supprimer une entrée d'un dictionnaire.
.pop() retire la paire (key, value) et renvoie la value pour utilisation.
Comme .get(), .pop(<key>) accepte un second argument (dict.pop(<key>, <default value>)) qui sera renvoyé si la key est introuvable.
Cela évite qu'une KeyError soit levée :
#Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'
#The "name" key is now removed from the dictionary.
#Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'name'
#Using a default argument with .pop() will prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'
Parcourir un dictionnaire en boucle
Parcourir un dictionnaire avec for item in dict ou while item n'itère que sur les clés par défaut.
On peut accéder aux valeurs dans la même boucle en utilisant des crochets :
>>> for key in bear:
>>> print((key, bear[key])) #this forms a tuple of (key, value) and prints it.
('name', 'Black Bear')
('speed', 40)
('land_animal', True)
On peut aussi utiliser la méthode .items(), qui renvoie automatiquement des tuples (key, value) :
#dict.items() forms (key, value tuples) that can be unpacked and iterated over.
>>> for key, value in whale.items():
>>> print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1
De même, la méthode .keys() renvoie les keys et la méthode .values() renvoie les values.
Exercice d'apprentissage
