Dictionnaires en Python

Python fournit un autre compositedata type appelédictionary, qui est similaire à une liste en ce sens qu'il s'agit d'une collection d'objets.

Here’s what you’ll learn in this tutorial: Vous découvrirez les caractéristiques de base des dictionnaires Python et apprendrez à accéder aux données de dictionnaire et à les gérer. Une fois ce didacticiel terminé, vous devez savoir quand un dictionnaire est le type de données approprié à utiliser et comment le faire.

Les dictionnaires et les listes partagent les caractéristiques suivantes:

Les deux sont mutables.
Les deux sont dynamiques. Ils peuvent grandir et rétrécir au besoin.
Les deux peuvent être imbriqués. Une liste peut contenir une autre liste. Un dictionnaire peut contenir un autre dictionnaire. Un dictionnaire peut également contenir une liste et vice versa.

Les dictionnaires diffèrent des listes principalement par la façon dont les éléments sont accessibles:

Les éléments de liste sont accessibles par leur position dans la liste, via l'indexation.
Les éléments du dictionnaire sont accessibles via des touches.

__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Dictionnaires Python». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

Fais le quiz "

Définition d'un dictionnaire

Les dictionnaires sont l'implémentation par Python d'une structure de données plus généralement connue sous le nom de tableau associatif. Un dictionnaire se compose d'une collection de paires clé-valeur. Chaque paire clé-valeur mappe la clé à sa valeur associée.

Vous pouvez définir un dictionnaire en plaçant une liste séparée par des virgules de paires clé-valeur entre accolades ({}). Un deux-points (:) sépare chaque clé de sa valeur associée:

d = {
    : ,
    : ,
      .
      .
      .
    : 
}

Ce qui suit définit un dictionnaire qui mappe un emplacement au nom de son équipe de baseball de Ligue majeure correspondante:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

Vous pouvez également créer un dictionnaire avec la fonctiondict() intégrée. L'argument dedict() doit être une séquence de paires clé-valeur. Une liste de tuples fonctionne bien pour cela:

d = dict([
    (, ),
    (, , )
])

MLB_team peut alors également être défini de cette manière:

>>>

>>> MLB_team = dict([
...     ('Colorado', 'Rockies'),
...     ('Boston', 'Red Sox'),
...     ('Minnesota', 'Twins'),
...     ('Milwaukee', 'Brewers'),
...     ('Seattle', 'Mariners')
... ])

Si les valeurs de clé sont de simples chaînes, elles peuvent être spécifiées comme arguments de mot clé. Voici donc encore une autre façon de définirMLB_team:

>>>

>>> MLB_team = dict(
...     Colorado='Rockies',
...     Boston='Red Sox',
...     Minnesota='Twins',
...     Milwaukee='Brewers',
...     Seattle='Mariners'
... )

Une fois que vous avez défini un dictionnaire, vous pouvez afficher son contenu, de la même manière que pour une liste. Les trois définitions ci-dessus apparaissent comme suit lorsqu'elles sont affichées:

>>>

>>> type(MLB_team)


>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Les entrées du dictionnaire s'affichent dans l'ordre dans lequel elles ont été définies. Mais cela n'a pas d'importance lorsqu'il s'agit de les récupérer. Les éléments du dictionnaire ne sont pas accessibles par index numérique:

>>>

>>> MLB_team[1]
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team[1]
KeyError: 1

Accès aux valeurs du dictionnaire

Bien sûr, les éléments du dictionnaire doivent être accessibles d'une manière ou d'une autre. Si vous ne les obtenez pas par index, comment les obtenez-vous?

Une valeur est extraite d'un dictionnaire en spécifiant sa clé correspondante entre crochets ([]):

>>>

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Si vous faites référence à une clé qui n'est pas dans le dictionnaire, Python lève une exception:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

L'ajout d'une entrée à un dictionnaire existant consiste simplement à attribuer une nouvelle clé et une nouvelle valeur:

>>>

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

Si vous souhaitez mettre à jour une entrée, vous pouvez simplement affecter une nouvelle valeur à une clé existante:

>>>

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

Pour supprimer une entrée, utilisez l'instructiondel, en spécifiant la clé à supprimer:

>>>

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Allez, Seahawks! Tu es une équipe de la NFL.

Clés de dictionnaire vs. Liste des indices

Vous avez peut-être remarqué que l'interpréteur lève la même exception,KeyError, lorsqu'un dictionnaire est accédé avec une clé non définie ou par un index numérique:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> MLB_team[1]
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team[1]
KeyError: 1

En fait, c'est la même erreur. Dans ce dernier cas,[1] ressemble à un index numérique, mais ce n’est pas le cas.

Vous verrez plus loin dans ce didacticiel qu'un objet de tout type immuable peut être utilisé comme clé de dictionnaire. En conséquence, il n'y a aucune raison pour laquelle vous ne pouvez pas utiliser d'entiers:

>>>

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

>>> d[0]
'a'
>>> d[2]
'c'

Dans les expressionsMLB_team[1],d[0] etd[2], les nombres entre crochets apparaissent comme s'il s'agissait d'indices. Mais ils n'ont rien à voir avec l'ordre des éléments du dictionnaire. Python les interprète comme des clés de dictionnaire. Si vous définissez ce même dictionnaire dans l'ordre inverse, vous obtenez toujours les mêmes valeurs en utilisant les mêmes clés:

>>>

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}

>>> d[0]
'a'
>>> d[2]
'c'

La syntaxe peut sembler similaire, mais vous ne pouvez pas traiter un dictionnaire comme une liste:

>>>

>>> type(d)


>>> d[-1]
Traceback (most recent call last):
  File "", line 1, in 
    d[-1]
KeyError: -1

>>> d[0:2]
Traceback (most recent call last):
  File "", line 1, in 
    d[0:2]
TypeError: unhashable type: 'slice'

>>> d.append('e')
Traceback (most recent call last):
  File "", line 1, in 
    d.append('e')
AttributeError: 'dict' object has no attribute 'append'

Note: Bien que l'accès aux éléments d'un dictionnaire ne dépende pas de l'ordre, Python garantit que l'ordre des éléments d'un dictionnaire est préservé. Lorsqu'ils sont affichés, les éléments apparaissent dans l'ordre dans lequel ils ont été définis, et l'itération à travers les touches se produit également dans cet ordre. Les éléments ajoutés à un dictionnaire sont ajoutés à la fin. Si des éléments sont supprimés, l'ordre des éléments restants est conservé.

Vous ne pouvez compter sur cette préservation de l'ordre que très récemment. C'étaitadded as a part of the Python language specification in version 3.7. Cependant, cela était vrai à partir de la version 3.6 également - par hasard à la suite de l'implémentation mais pas garanti par la spécification du langage.

Création incrémentielle d'un dictionnaire

La définition d'un dictionnaire à l'aide d'accolades et d'une liste de paires clé-valeur, comme indiqué ci-dessus, est correcte si vous connaissez toutes les clés et les valeurs à l'avance. Mais que faire si vous voulez créer un dictionnaire à la volée?

Vous pouvez commencer par créer un dictionnaire vide, qui est spécifié par des accolades vides. Ensuite, vous pouvez ajouter de nouvelles clés et valeurs une à la fois:

>>>

>>> person = {}
>>> type(person)


>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

Une fois le dictionnaire créé de cette manière, ses valeurs sont accessibles de la même manière que tout autre dictionnaire:

>>>

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}

>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

La récupération des valeurs dans la sous-liste ou sous-juridictionnelle nécessite un index ou une clé supplémentaire:

>>>

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

Cet exemple présente une autre caractéristique des dictionnaires: les valeurs contenues dans le dictionnaire n'ont pas besoin d'être du même type. Dansperson, certaines des valeurs sont des chaînes, une est un entier, une est une liste et une est un autre dictionnaire.

Tout comme les valeurs d'un dictionnaire n'ont pas besoin d'être du même type, les clés n'ont pas non plus:

>>>

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

Ici, l'une des clés est un entier, une est un flottant et une est un booléen. On ne sait pas trop comment cela serait utile, mais on ne sait jamais.

Remarquez à quel point les dictionnaires Python sont polyvalents. EnMLB_team, la même information (le nom de l'équipe de baseball) est conservée pour chacun des différents emplacements géographiques. person, d'autre part, stocke différents types de données pour une seule personne.

Vous pouvez utiliser des dictionnaires à des fins très diverses car il y a si peu de limitations sur les clés et les valeurs autorisées. Mais il y en a. Continuer à lire!

Restrictions sur les clés de dictionnaire

Presque n'importe quel type de valeur peut être utilisé comme clé de dictionnaire en Python. Vous venez de voir cet exemple, où des objets entiers, flottants et booléens sont utilisés comme clés:

>>>

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Vous pouvez même utiliser des objets intégrés comme des types et des fonctions:

>>>

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{: 1, : 2, : 3}
>>> d[float]
2

>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Cependant, il existe quelques restrictions que les clés de dictionnaire doivent respecter.

Tout d'abord, une clé donnée ne peut apparaître dans un dictionnaire qu'une seule fois. Les clés en double ne sont pas autorisées. Un dictionnaire mappe chaque clé sur une valeur correspondante, il n’a donc pas de sens de mapper une clé particulière plusieurs fois.

Vous avez vu ci-dessus que lorsque vous affectez une valeur à une clé de dictionnaire déjà existante, elle n'ajoute pas la clé une deuxième fois, mais remplace la valeur existante:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

De même, si vous spécifiez une clé une deuxième fois lors de la création initiale d'un dictionnaire, la deuxième occurrence remplacera la première:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Timberwolves',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners',
...     'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Allez, Timberwolves! Tu es une équipe NBA. Sorte de.

Deuxièmement, une clé de dictionnaire doit être d'un type immuable. Vous avez déjà vu des exemples où plusieurs des types immuables que vous connaissez - entier, flottant, chaîne et booléen - ont servi de clés de dictionnaire.

Un tuple peut également être une clé de dictionnaire, car les tuples sont immuables:

>>>

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

(Rappelez-vous de la discussion surtuples qu'une des raisons d'utiliser un tuple au lieu d'une liste est qu'il y a des circonstances où un type immuable est requis. C'est l'un d'eux.)

Cependant, ni une liste ni un autre dictionnaire ne peuvent servir de clé de dictionnaire, car les listes et les dictionnaires sont mutables:

>>>

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last):
  File "", line 1, in 
    d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

Technical Note: Pourquoi le message d'erreur dit «indéchirable»?

Techniquement, il n'est pas tout à fait correct de dire qu'un objet doit être immuable pour être utilisé comme clé de dictionnaire. Plus précisément, un objet doit êtrehashable, ce qui signifie qu'il peut être passé à une fonction de hachage. Une fonction de hachage prend des données de taille arbitraire et les mappe à une valeur de taille fixe relativement plus simple appeléehash value (ou simplement hachage), qui est utilisée pour la recherche et la comparaison de table.

La fonctionhash() intégrée de Python renvoie la valeur de hachage d’un objet hachable et lève une exception pour un objet qui n’est pas:

>>>

>>> hash('foo')
11132615637596761

>>> hash([1, 2, 3])
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unhashable type: 'list'

Tous les types immuables intégrés que vous avez connus jusqu'à présent sont lavables, et les types de conteneurs modifiables (listes et dictionnaires) ne le sont pas. Donc, pour les besoins actuels, vous pouvez considérer comme lavable et immuable plus ou moins synonyme.

Dans les futurs tutoriels, vous rencontrerez des objets mutables qui sont également hachables.

Restrictions sur les valeurs de dictionnaire

En revanche, il n'y a aucune restriction sur les valeurs du dictionnaire. Littéralement pas du tout. Une valeur de dictionnaire peut être n'importe quel type d'objet pris en charge par Python, y compris les types mutables tels que les listes et les dictionnaires, et les objets définis par l'utilisateur, que vous découvrirez dans les prochains didacticiels.

Il n'y a également aucune restriction à ce qu'une valeur particulière apparaisse plusieurs fois dans un dictionnaire:

>>>

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Opérateurs et fonctions intégrées

Vous vous êtes déjà familiarisé avec de nombreux opérateurs et fonctions intégrées qui peuvent être utilisés avecstrings,lists ettuples. Certains d'entre eux fonctionnent également avec des dictionnaires.

Par exemple, les opérateursin etnot in renvoientTrue ouFalse selon que l'opérande spécifié apparaît comme clé dans le dictionnaire:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

Vous pouvez utiliser l'opérateurin avec une évaluation de court-circuit pour éviter de générer une erreur lors de la tentative d'accès à une clé qui ne figure pas dans le dictionnaire:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

Dans le second cas, en raison d'une évaluation de court-circuit, l'expressionMLB_team['Toronto'] n'est pas évaluée, donc l'exceptionKeyError ne se produit pas.

La fonctionlen() renvoie le nombre de paires clé-valeur dans un dictionnaire:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }
>>> len(MLB_team)
5

Méthodes de dictionnaire intégrées

Comme pour les chaînes et les listes, il existe plusieurs méthodes intégrées qui peuvent être invoquées dans les dictionnaires. En fait, dans certains cas, les méthodes de liste et de dictionnaire partagent le même nom. (Dans la discussion sur la programmation orientée objet, vous verrez qu'il est parfaitement acceptable que différents types aient des méthodes avec le même nom.)

Voici un aperçu des méthodes qui s'appliquent aux dictionnaires:

`d.clear()`

Efface un dictionnaire.

d.clear() vide le dictionnaired de toutes les paires clé-valeur:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> d.clear()
>>> d
{}

`d.get([, ])`

Renvoie la valeur d'une clé si elle existe dans le dictionnaire.

La méthode du dictionnaire Python.get() fournit un moyen pratique d'obtenir la valeur d'une clé à partir d'un dictionnaire sans vérifier à l'avance si la clé existe, et sans générer d'erreur.

d.get(<key>) recherche dans le dictionnaired<key> et renvoie la valeur associée si elle est trouvée. Si<key> n'est pas trouvé, il renvoieNone:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Si<key> n'est pas trouvé et que l'argument optionnel<default> est spécifié, cette valeur est renvoyée à la place deNone:

>>>

>>> print(d.get('z', -1))
-1

`d.items()`

Renvoie une liste de paires clé-valeur dans un dictionnaire.

d.items() renvoie une liste de tuples contenant les paires clé-valeur end. Le premier élément de chaque tuple est la clé et le deuxième élément est la valeur de la clé:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

`d.keys()`

Renvoie une liste de clés dans un dictionnaire.

d.keys() renvoie une liste de toutes les clés ded:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.keys())
['a', 'b', 'c']

`d.values()`

Renvoie une liste de valeurs dans un dictionnaire.

d.values() renvoie une liste de toutes les valeurs ded:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.values())
[10, 20, 30]

Toutes les valeurs en double dansd seront renvoyées autant de fois qu'elles se produisent:

>>>

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}

>>> list(d.values())
[10, 10, 10]

Technical Note: Les méthodes.items(),.keys() et.values() renvoient en fait quelque chose appeléview object. Un objet vue dictionnaire ressemble plus ou moins à une fenêtre sur les clés et les valeurs. À des fins pratiques, vous pouvez considérer ces méthodes comme renvoyant des listes de clés et de valeurs du dictionnaire.

`d.pop([, ])`

Supprime une clé d'un dictionnaire, si elle est présente, et renvoie sa valeur.

Si<key> est présent dansd,d.pop(<key>) supprime<key> et renvoie sa valeur associée:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop(<key>) lève une exceptionKeyError si<key> n'est pas dansd:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('z')
Traceback (most recent call last):
  File "", line 1, in 
    d.pop('z')
KeyError: 'z'

Si<key> n'est pas dansd et que l'argument optionnel<default> est spécifié, alors cette valeur est renvoyée et aucune exception n'est déclenchée:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

`d.popitem()`

Supprime une paire clé-valeur d'un dictionnaire.

d.popitem() supprime une paire clé-valeur aléatoire et arbitraire ded et la renvoie sous forme de tuple:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}

>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Sid est vide,d.popitem() lève une exceptionKeyError:

>>>

>>> d = {}
>>> d.popitem()
Traceback (most recent call last):
  File "", line 1, in 
    d.popitem()
KeyError: 'popitem(): dictionary is empty'

`d.update()`

Fusionne un dictionnaire avec un autre dictionnaire ou avec un itérable de paires clé-valeur.

Si<obj> est un dictionnaire,d.update(<obj>) fusionne les entrées de<obj> dansd. Pour chaque clé en<obj>:

Si la clé n'est pas présente dansd, la paire clé-valeur de<obj> est ajoutée àd.
Si la clé est déjà présente dansd, la valeur correspondante end pour cette clé est mise à jour à la valeur de<obj>.

Voici un exemple montrant deux dictionnaires fusionnés:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}

>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Dans cet exemple, la clé'b' existe déjà dansd1, donc sa valeur est mise à jour à200, la valeur de cette clé à partir ded2. Cependant, il n'y a pas de clé'd' dansd1, de sorte que la paire clé-valeur est ajoutée à partir ded2.

<obj> peut également être une séquence de paires clé-valeur, comme lorsque la fonctiondict() est utilisée pour définir un dictionnaire. Par exemple,<obj> peut être spécifié comme une liste de tuples:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Ou les valeurs à fusionner peuvent être spécifiées sous la forme d'une liste d'arguments de mots clés:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Conclusion

Dans ce didacticiel, vous avez couvert les propriétés de base de Pythondictionary et appris à accéder et à manipuler les données du dictionnaire.

Lists etdictionaries sont deux des types Python les plus fréquemment utilisés. Comme vous l'avez vu, ils ont plusieurs similitudes, mais diffèrent dans la façon dont leurs éléments sont accessibles. Les éléments de listes sont accessibles par index numérique basé sur l'ordre, et les éléments de dictionnaire sont accessibles par clé

En raison de cette différence, les listes et les dictionnaires ont tendance à être adaptés à différentes circonstances. Vous devriez maintenant avoir une bonne idée de ce qui, le cas échéant, serait le mieux pour une situation donnée.

Ensuite, vous découvrirez Pythonsets. L'ensemble est un autre type de données composite, mais il est assez différent d'une liste ou d'un dictionnaire.

Fais le quiz "

TOC

Dictionnaires en Python