Dictionnaires en

À propos de Dictionnaires

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 mappage intégré à Python.

Les keys doivent être hachables et uniques au sein du dictionnaire. Les types de clés peuvent être des number, des str ou des tuple (de valeurs immuables). Ils ne peuvent pas contenir de structures de données muables telles que des list, des dict ou des set. Depuis Python 3.7, l'ordre des clés d'un dict est garanti comme étant l'ordre dans lequel les entrées sont insérées.

Les values peuvent être de n'importe quel type ou structure de données. Les valeurs peuvent aussi s'imbriquer de façon arbitraire, et donc contenir des listes de listes, des sous-dictionnaires et d'autres structures de données personnalisées ou composées.

À partir d'une key, un dictionnaire peut récupérer une value en temps constant (en moyenne, et 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 consomme 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 grande et qu'il faut y accéder et la mettre à jour fréquemment.

Construction d'un dictionnaire

On peut créer un dictionnaire de bien des façons, notamment :

• En utilisant la méthode de classe fromkeys().
• En utilisant des compréhensions de dictionnaire.
• En fusionnant deux dictionnaires par dépaquetage (**).
• En fusionnant des dictionnaires avec l'opérateur | (update).
• En utilisant une boucle pour ajouter des entrées une à une à un dict vide créé au préalable.

Les deux méthodes les plus directes sont le constructeur de dictionnaire et le littéral de dictionnaire.

Le constructeur de dictionnaire

dict() (le constructeur de la classe dict) peut être utilisé avec n'importe quel itérable de paires key, value. On peut aussi l'appeler 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}

La documentation sur les dict décrit d'autres variantes et options d'utilisation du constructeur.

Littéraux de dictionnaire

On peut aussi saisir un dictionnaire directement sous forme de littéral de dictionnaire, avec des accolades ({}) qui encadrent des paires key : value. Les entrées encadrées par les {} peuvent aussi être réparties sur plusieurs lignes :

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

Dictionnaires imbriqués

Les dictionnaires peuvent s'imbriquer de façon arbitraire :

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

Accéder aux valeurs d'un dict

On accède à une value d'un dictionnaire à l'aide d'une clé entre crochets. Si une clé n'existe pas dans le dictionnaire, 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'

Accéder aux entrées d'un dictionnaire imbriqué

Pour accéder aux entrées d'un dictionnaire imbriqué, on enchaîne les crochets. Si une clé est absente, la KeyError habituelle est levée :

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

Pour éviter la KeyError, on peut utiliser .get(), mais les appels à .get() doivent être enchaînés :

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

Modifier ou ajouter des valeurs dans un dictionnaire

On modifie la value d'une entrée en affectant une nouvelle valeur à 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 façon :

# 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 des entrées de dictionnaire (avec pop et del)

On peut utiliser la méthode <dict>.pop(<key>) pour supprimer une entrée d'un dictionnaire. <dict>.pop() retire la paire (key, value) et renvoie la value pour qu'on puisse l'utiliser. Comme <dict>.get(), <dict>.pop(<key>) accepte un second argument (<dict>.pop(<key>, <default value>)) qui sera renvoyé si la key est introuvable. Cela évite de lever une KeyError :

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

On peut aussi utiliser l'instruction del pour supprimer une ou plusieurs entrées. Une KeyError est levée si l'entrée à supprimer est introuvable dans le dictionnaire :

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

Parcourir un dictionnaire

Parcourir un dictionnaire avec for item in dict ou while item itère 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 prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

On peut aussi utiliser la méthode .items(), qui renvoie 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, .keys() renvoie les keys et .values() renvoie les values.

Pour une explication détaillée des dictionnaires en Python, la documentation officielle est un excellent point de départ, et tu peux aussi consulter le tutoriel W3-Schools.

Étendre les fonctionnalités d'un dictionnaire : le module collections

Le module collections ajoute des fonctionnalités spécialisées aux types de collections standard de Python (dict, set, list, tuple). Voici trois des classes les plus utiles basées sur les dictionnaires :

• Counter compte automatiquement les éléments et les renvoie dans un dict qui a les éléments pour clés et leurs nombres pour valeurs.
• OrderedDict dispose de méthodes spécialisées pour organiser l'ordre des entrées d'un dictionnaire.
• defaultdict utilise une méthode de fabrique pour définir une valeur par défaut si une key est introuvable lors de la récupération ou de l'affectation d'une entrée de dictionnaire.