Python Language
dictionnaire

Syntaxe

• mydict = {}
• mydict [k] = valeur
• valeur = mydict [k]
• valeur = mydict.get (k)
• value = mydict.get (k, "default_value")

Paramètres

Remarques

Accéder aux valeurs d'un dictionnaire

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

Le code ci-dessus imprimera 1234 .

La chaîne "Hello" dans cet exemple est appelée une clé . Il est utilisé pour rechercher une valeur dans le dict en plaçant la clé entre crochets.

Le nombre 1234 est vu après les deux points respectifs dans la définition dict . Ceci s'appelle la valeur à laquelle "Hello" correspond dans ce dict .

Rechercher une valeur comme celle-ci avec une clé inexistante KeyError une exception KeyError , stoppant l'exécution si elle n'est pas KeyError . Si nous voulons accéder à une valeur sans risquer une KeyError , nous pouvons utiliser la méthode dictionary.get . Par défaut, si la clé n'existe pas, la méthode renvoie None . Nous pouvons lui transmettre une seconde valeur à retourner au lieu de None en cas d'échec de la recherche.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

Dans cet exemple, w obtiendra la valeur None et x obtiendra la valeur "nuh-uh" .

Le constructeur dict ()

Le constructeur dict() peut être utilisé pour créer des dictionnaires à partir d’arguments de mots-clés, ou à partir d’une seule itération de paires clé-valeur, ou à partir d’un seul dictionnaire et d’arguments de mots-clés.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

Éviter les exceptions de KeyError

Un écueil courant lors de l’utilisation des dictionnaires est d’accéder à une clé inexistante. Cela se traduit généralement par une exception KeyError

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

Un moyen d'éviter les erreurs de clé consiste à utiliser la méthode dict.get , qui vous permet de spécifier une valeur par défaut à renvoyer dans le cas d'une clé absente.

value = mydict.get(key, default_value)

Qui renvoie mydict[key] s'il existe, mais renvoie default_value . Notez que cela n'ajoute pas de key à mydict . Donc , si vous voulez conserver cette valeur paire de clés, vous devez utiliser mydict.setdefault(key, default_value) , qui ne stocke la paire de valeurs clés.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

Une autre façon de faire face au problème est d’accepter l’exception

try:
    value = mydict[key]
except KeyError:
    value = default_value

Vous pouvez également vérifier si la clé est in le dictionnaire.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

Notez toutefois que, dans les environnements multithread, la clé peut être supprimée du dictionnaire après vérification, créant ainsi une condition de concurrence où l'exception peut toujours être levée.

Une autre option consiste à utiliser une sous-classe de dict, collections.defaultdict, qui possède une propriété default_factory pour créer de nouvelles entrées dans le dict lorsqu'une nouvelle clé est donnée.

Accéder aux clés et aux valeurs

Lorsque vous travaillez avec des dictionnaires, il est souvent nécessaire d'accéder à toutes les clés et valeurs du dictionnaire, soit dans une boucle for , une compréhension de liste, ou simplement sous la forme d'une liste simple.

Étant donné un dictionnaire comme:

mydict = {
    'a': '1',
    'b': '2'
}

Vous pouvez obtenir une liste de clés en utilisant la méthode keys() :

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

Si, au contraire, vous souhaitez une liste de valeurs, utilisez la méthode values() :

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

Si vous voulez travailler avec la clé et la valeur correspondante, vous pouvez utiliser la méthode items() :

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

Remarque: comme un dict est non trié, keys() , values() et items() n'ont aucun ordre de tri. Utilisez sort() , sorted() , ou un OrderedDict si vous vous souciez de l'ordre que ces méthodes renvoient.

Différence Python 2/3: Dans Python 3, ces méthodes renvoient des objets itérables spéciaux, pas des listes, et sont l'équivalent des iterkeys() Python 2 iterkeys() , itervalues() et iteritems() . Ces objets peuvent être utilisés comme des listes pour la plupart, bien qu'il y ait des différences. Voir PEP 3106 pour plus de détails.

Introduction au dictionnaire

Un dictionnaire est un exemple de magasin de valeurs de clé également appelé Mapping in Python. Il vous permet de stocker et de récupérer des éléments en référençant une clé. Comme les dictionnaires sont référencés par clé, ils ont des recherches très rapides. Comme ils sont principalement utilisés pour référencer les éléments par clé, ils ne sont pas triés.

créer un dict

Les dictionnaires peuvent être initiés de plusieurs manières:

syntaxe littérale

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

dict compréhension

d = {k:v for k,v in [('key', 'value',)]}

voir aussi: Compréhensions

classe intégrée: dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

modifier un dict

Pour ajouter des éléments à un dictionnaire, créez simplement une nouvelle clé avec une valeur:

d['newkey'] = 42

Il est également possible d'ajouter une list et un dictionary tant que valeur:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

Pour supprimer un élément, supprimez la clé du dictionnaire:

del d['newkey']

Dictionnaire avec les valeurs par défaut

Disponible dans la bibliothèque standard en tant que defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] Alternativement, si vous devez utiliser la classe dict using dict.setdefault() , l' using dict.setdefault() vous permettra de créer une valeur par défaut à chaque fois que vous accédez à une clé qui n'existait pas auparavant:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

Gardez à l'esprit que si vous avez beaucoup de valeurs à ajouter, dict.setdefault() créera une nouvelle instance de la valeur initiale (dans cet exemple, a [] ) à chaque appel, ce qui peut créer des charges de travail inutiles.

[*] Python Cookbook, 3ème édition, par David Beazley et Brian K. Jones (O'Reilly). Copyright 2013 David Beazley et Brian Jones, 978-1-449-34037-7.

Créer un dictionnaire ordonné

Vous pouvez créer un dictionnaire ordonné qui suivra un ordre déterminé lors d'une itération sur les clés du dictionnaire.

Utilisez OrderedDict du module de collections . Cela renverra toujours les éléments du dictionnaire dans l'ordre d'insertion d'origine une fois l'itération terminée.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

Déballage des dictionnaires à l'aide de l'opérateur **

Vous pouvez utiliser l'opérateur de décompression d'argument de mot clé ** pour fournir les paires clé-valeur dans un dictionnaire aux arguments d'une fonction. Un exemple simplifié de la documentation officielle :

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

A partir de Python 3.5, vous pouvez également utiliser cette syntaxe pour fusionner un nombre arbitraire d'objets dict .

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Comme le montre cet exemple, les clés en double correspondent à leur valeur la plus récente (par exemple, "Clifford" remplace "Nemo").

Fusion de dictionnaires

Considérons les dictionnaires suivants:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Comme le montre cet exemple, les clés en double correspondent à leur valeur la plus récente (par exemple, "Clifford" remplace "Nemo").

Python 3.3+

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

Avec cette technique, la valeur la plus importante prime sur une clé donnée plutôt que sur la dernière ("Clifford" est rejeté en faveur de "Nemo").

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Cela utilise la dernière valeur, comme avec la technique basée sur ** pour la fusion ("Clifford" remplace "Nemo").

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update utilise le dernier dict pour écraser le précédent.

La virgule de fin

Comme les listes et les tuples, vous pouvez inclure une virgule de fin dans votre dictionnaire.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8 stipule que vous devez laisser un espace entre la virgule finale et l'accolade de fermeture.

Toutes les combinaisons de valeurs de dictionnaire

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

Étant donné un dictionnaire tel que celui montré ci-dessus, où il y a une liste représentant un ensemble de valeurs à explorer pour la clé correspondante. Supposons que vous vouliez explorer "x"="a" avec "y"=10 , puis "x"="a" avec "y"=10 , et ainsi de suite jusqu'à ce que vous ayez exploré toutes les combinaisons possibles.

Vous pouvez créer une liste qui renvoie toutes ces combinaisons de valeurs en utilisant le code suivant.

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

Cela nous donne la liste suivante stockée dans les combinations variables:

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

Itérer sur un dictionnaire

Si vous utilisez un dictionnaire en tant qu'itérateur (par exemple dans une déclaration for ), il parcourt les clés du dictionnaire. Par exemple:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

La même chose est vraie lorsqu'elle est utilisée dans une compréhension

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

Créer un dictionnaire

Règles pour créer un dictionnaire:

• Chaque clé doit être unique (sinon elle sera remplacée)
• Chaque clé doit être hashable (peut utiliser le hash fonction de hachage il, sinon TypeError sera jeté)
• Il n'y a pas d'ordre particulier pour les clés.

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

Exemple de dictionnaires

Dictionnaires mappent les clés aux valeurs.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

Les valeurs du dictionnaire sont accessibles par leurs clés.

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

Les dictionnaires peuvent également être créés dans un style JSON:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

Les valeurs de dictionnaire peuvent être réitérées sur:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette