Comment puis-je ajouter de nouvelles clés à un dictionnaire?

2625

Est-il possible d'ajouter une clé à un dictionnaire Python après sa création?

Il ne semble pas avoir de .add()méthode.

lfaraone
la source
25
Si vous êtes ici pour essayer de comprendre comment ajouter une clé et retourner un nouveau dictionnaire, vous pouvez le faire sur python3.5 +: {**mydict, 'new_key': new_val}.
cs95
Utilisez la réponse acceptée: d ['mynewkey'] = 'mynewvalue' ou vous pouvez utiliser val = d.setdefault ('mynewkey', 'mynewvalue')
Ol 'Dawg

Réponses:

3406
d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}
Paolo Bergantino
la source
108
L'explication est la suivante: vous créez une nouvelle paire clé / valeur sur un dictionnaire en attribuant une valeur à cette clé. Si la clé n'existe pas, elle est ajoutée et pointe vers cette valeur. S'il existe, la valeur actuelle vers laquelle il pointe est écrasée.
R. Navega
9
Quelle est la différence entre cela et la .update()méthode? Quel est le meilleur moment?
hegash
14
@hegash la d[key]=valsyntaxe car elle est plus courte et peut gérer n'importe quel objet comme clé (tant qu'elle est hachable), et ne définit qu'une seule valeur, alors que .update(key1=val1, key2=val2)c'est plus agréable si vous souhaitez définir plusieurs valeurs en même temps, tant que les clés sont des chaînes (puisque les kwargs sont convertis en chaînes). dict.updatepeut également prendre un autre dictionnaire, mais je préfère personnellement ne pas créer explicitement un nouveau dictionnaire afin d'en mettre à jour un autre.
bgusach
essayez-le, voici un exemple: repl.it/@SmaMa/Add-key-to-dict
Sma Ma
comment puis-je ajouter un élément dans un dict imbriqué. Comme php$foo[ ] = [ . . . . ]
Juan-Kabbali
1044

Pour ajouter plusieurs clés simultanément, utilisez dict.update():

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

Pour ajouter une seule clé, la réponse acceptée a moins de temps de calcul.

Peter Mortensen
la source
13
c'est tellement inefficace pour créer un dictionnaire juste pour mettre à jour une clé. Ne faites cela que si vous avez plus d'une clé (il peut y avoir un seuil au-dessus duquel il vaut mieux créer un dict)
Jean-François Fabre
10
@ Jean-FrançoisFabre Ceci est un exemple de code. Vous ne devriez vraiment pas considérer les réponses comme couvrant tous les cas.
Robert Brisita
1
cela donne la fausse impression que c'est la façon préférée d'ajouter une clé.
Jean-François Fabre
@ Jean-FrançoisFabre Étant donné que l' ordre des dicts est garanti dans Python 3.7+ (et fourni dans 3.6+) , cela pourrait bien être un moyen préféré d'ajouter une seule clé lorsque l' ordre est important .
ingyhere
si vous créez une autre clé comme x[-1] = 44la -1valeur est également à la fin. Quoi qu'il en soit, la réponse a été modifiée et est bien meilleure maintenant. La mise à jour avec un dictionnaire est bonne lorsqu'il est probable qu'elle contient de nombreux éléments.
Jean-François Fabre
931

J'ai envie de consolider les informations sur les dictionnaires Python:

Création d'un dictionnaire vide

data = {}
# OR
data = dict()

Création d'un dictionnaire avec des valeurs initiales

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

Insertion / mise à jour d'une valeur unique

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

Insertion / mise à jour de plusieurs valeurs

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

Créer un dictionnaire fusionné sans modifier les originaux

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

Suppression d'éléments dans le dictionnaire

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

Vérifiez si une clé est déjà dans le dictionnaire

key in data

Itérer à travers des paires dans un dictionnaire

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

Créez un dictionnaire à partir de deux listes

data = dict(zip(list_with_keys, list_with_values))

Nouveau dans Python 3.5

Créer un dictionnaire fusionné sans modifier les originaux:

Cela utilise une nouvelle valeur appelée décompression de dictionnaire .

data = {**data1, **data2, **data3}

Nouveau dans Python 3.9

Mettre à jour ou ajouter des valeurs pour un dictionnaire existant

L' opérateur de mise à jour |= fonctionne désormais pour les dictionnaires:

data |= {'c':3,'d':4}

Créer un dictionnaire fusionné sans modifier les originaux

L' opérateur de fusion | fonctionne désormais pour les dictionnaires:

data = data1 | {'c':3,'d':4}

N'hésitez pas à en ajouter plus!

Yugal Jindle
la source
145

"Est-il possible d'ajouter une clé à un dictionnaire Python après sa création? Il ne semble pas avoir de méthode .add ()."

Oui, c'est possible, et il a une méthode qui l'implémente, mais vous ne voulez pas l'utiliser directement.

Pour montrer comment et comment ne pas l'utiliser, créons un dict vide avec le littéral dict {}:

my_dict = {}

Meilleure pratique 1: notation en indice

Pour mettre à jour ce dict avec une seule nouvelle clé et valeur, vous pouvez utiliser la notation en indice (voir Mappages ici) qui prévoit l'affectation des éléments:

my_dict['new key'] = 'new value'

my_dict est maintenant:

{'new key': 'new value'}

Meilleure pratique 2: La updateméthode - 2 façons

Nous pouvons également mettre à jour le dict avec plusieurs valeurs efficacement en utilisant la updateméthode . Nous pouvons créer inutilement un supplément dictici, nous espérons donc que notre dicta déjà été créé et provient ou a été utilisé à une autre fin:

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict est maintenant:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

Une autre façon efficace de le faire avec la méthode de mise à jour est avec les arguments de mots clés, mais comme ils doivent être des mots python légitimes, vous ne pouvez pas avoir d'espaces ou de symboles spéciaux ou commencer le nom par un nombre, mais beaucoup considèrent cela comme un moyen plus lisible pour créer des clés pour un dict, et ici nous évitons certainement de créer un extra inutile dict:

my_dict.update(foo='bar', foo2='baz')

et my_dictc'est maintenant:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

Alors maintenant, nous avons couvert trois façons Pythoniques de mettre à jour a dict.


Méthode magique __setitem__, et pourquoi il faut l'éviter

Il existe une autre façon de mettre à jour un dictque vous ne devriez pas utiliser, qui utilise la __setitem__méthode. Voici un exemple de la façon dont on pourrait utiliser la __setitem__méthode pour ajouter une paire clé-valeur à a dict, et une démonstration des mauvaises performances de son utilisation:

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

Nous voyons donc que l'utilisation de la notation en indice est en réalité beaucoup plus rapide que l'utilisation __setitem__. Faire la chose Pythonic, c'est-à-dire utiliser le langage de la façon dont il était censé être utilisé, est généralement à la fois plus lisible et plus efficace en termes de calcul.

Aaron Hall
la source
1
La différence est plutôt moins marquée en 2020 (sur ma machine, 1,35 ms en indice vs 2ms pour d.__setitem__), bien que la conclusion (et surtout la dernière phrase) reste solide. Hisser la recherche de nom de méthode hors de la boucle a réduit le temps à environ 1,65 ms; la différence restante est probablement due en grande partie à la surcharge inévitable du mécanisme d'appel Python.
holdenweb
96
dictionary[key] = value
Jason Creighton
la source
58

Si vous souhaitez ajouter un dictionnaire dans un dictionnaire, vous pouvez le faire de cette façon.

Exemple: ajoutez une nouvelle entrée à votre dictionnaire et sous-dictionnaire

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

Production:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

REMARQUE: Python nécessite que vous ajoutiez d'abord un sous

dictionary["dictionary_within_a_dictionary"] = {}

avant d'ajouter des entrées.

Asher
la source
13
cela n'a pas autant d'importance pour la question posée que la plupart des commentaires dans les pages de manuel de php.net ...
Erik Kaplun
2
Rien pour vous empêcher de faire cela sur une seule ligne: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}(ou si dictionaryc'est déjà un dict, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})
Chris
43

La syntaxe orthodoxe est d[key] = value, mais si votre clavier ne contient pas les touches du crochet, vous pouvez le faire:

d.__setitem__(key, value)

En fait, définir __getitem__et __setitem__méthodes est la façon dont vous pouvez faire en sorte que votre propre classe prenne en charge la syntaxe entre crochets. Voir https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php

Colonel Panic
la source
16
Je trouverais extrêmement difficile de programmer avec python sans les touches de support de mon clavier.
Bobort
2
C'était le seul moyen que je pouvais trouver pour définir des valeurs de dictionnaire dans une liste de compréhension. Merci
chris stevens
3
@chrisstevens si vous voulez définir une valeur dans une compréhension qu'un hack j'ai utilisé est [a for a in my_dict if my_dict.update({'a': 1}) is None].
Jeremy Logan
Curieux ... est-ce courant (c'est-à-dire des crochets manquants)?
Aleister Tanek Javas Mraz
@chrisstevens @JeremyLogan Pourquoi utiliser une compréhension de liste quand vous pouvez utiliser une compréhension de dict? {v: k for k, v in my_dict.items() if <some_conditional_check>}
ingyhere
36

Vous pouvez en créer un:

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

Donne:

>>> 
{'apples': 6, 'bananas': 3}
kiriloff
la source
31

Cette question populaire porte sur les méthodes fonctionnelles de fusion des dictionnaires aet des b.

Voici quelques-unes des méthodes les plus simples (testées en Python 3) ...

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

Remarque: La première méthode ci-dessus ne fonctionne que si les clés bsont des chaînes.

Pour ajouter ou modifier un seul élément , le bdictionnaire ne contiendrait qu'un seul élément ...

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

Cela équivaut à ...

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )
nobar
la source
8
Commentaire intéressant sur la première méthode du BDFL de Python ( ici ).
nobar
c = dict( a, **{'d':'dog'} )serait mieux écrit tant c = dict(a, d='dog')que les clés sont connues et non calculées.
holdenweb
21

Imaginons que vous vouliez vivre dans le monde immuable et que vous ne vouliez PAS modifier l'original mais que vous vouliez en créer un nouveau dictqui résulte de l'ajout d'une nouvelle clé à l'original.

Dans Python 3.5+, vous pouvez faire:

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

L'équivalent Python 2 est:

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

Après l'un ou l'autre:

params est toujours égal à {'a': 1, 'b': 2}

et

new_params est égal à {'a': 1, 'b': 2, 'c': 3}

Il y aura des moments où vous ne voudrez pas modifier l'original (vous voulez seulement le résultat de l'ajout à l'original). Je trouve cela une alternative rafraîchissante aux suivantes:

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

ou

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

Référence: https://stackoverflow.com/a/2255892/514866

campeterson
la source
2
Au cours d'une longue conversation avec un collègue de programmation pro-fonctionnel, un bon point a été soulevé. Un inconvénient de l'approche ci-dessus est que si quelqu'un qui lit le code n'est pas familier avec **Python (beaucoup ne le sont pas), ce ne sera pas évident. Il y a des moments où vous privilégiez une approche moins fonctionnelle pour une meilleure lisibilité.
campeterson
5
Nous ne pouvons pas prévoir quel sous-ensemble du langage Python nos lecteurs connaissent, il est donc juste de supposer qu'ils connaissent le langage entier afin qu'ils recherchent dans les documents les parties qu'ils ne connaissent pas.
Gabriel
17

Tant de réponses et tout le monde a oublié le nom étrange, le comportement étrange et pourtant toujours pratique dict.setdefault()

Cette

value = my_dict.setdefault(key, default)

fait simplement ceci:

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

par exemple

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored
Michael Ekoka
la source
5

Si vous ne joignez pas deux dictionnaires, mais que vous ajoutez de nouvelles paires clé-valeur à un dictionnaire, l'utilisation de la notation en indice semble être la meilleure façon.

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

Cependant, si vous souhaitez ajouter, par exemple, des milliers de nouvelles paires valeur / clé, vous devriez envisager d'utiliser la update()méthode.

Burak Özdemir
la source
3

Je pense qu'il serait également utile de souligner le collectionsmodule de Python qui se compose de nombreuses sous-classes et wrappers de dictionnaire utiles qui simplifient l' ajout et la modification des types de données dans un dictionnaire , en particulier defaultdict:

dicter la sous-classe qui appelle une fonction d'usine pour fournir des valeurs manquantes

Cela est particulièrement utile si vous travaillez avec des dictionnaires qui sont toujours constitués des mêmes types de données ou structures, par exemple un dictionnaire de listes.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

Si la clé n'existe pas encore, defaultdictaffecte la valeur donnée (dans notre cas 10) comme valeur initiale au dictionnaire (souvent utilisée dans les boucles). Cette opération fait donc deux choses: elle ajoute une nouvelle clé à un dictionnaire (selon la question), et affecte la valeur si la clé n'existe pas encore. Avec le dictionnaire standard, cela aurait déclenché une erreur car l' +=opération tente d'accéder à une valeur qui n'existe pas encore:

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

Sans l'utilisation de defaultdict, la quantité de code pour ajouter un nouvel élément serait beaucoup plus grande et ressemblerait peut-être à quelque chose comme:

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdictpeut également être utilisé avec des types de données complexes tels que listet set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

L'ajout d'un élément initialise automatiquement la liste.

m_____z
la source
3

Voici une autre façon que je n'ai pas vue ici:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

Vous pouvez utiliser le constructeur de dictionnaire et l'expansion implicite pour reconstruire un dictionnaire. De plus, il est intéressant de noter que cette méthode peut être utilisée pour contrôler l'ordre de position lors de la construction du dictionnaire ( post Python 3.6 ). En fait, l'ordre d'insertion est garanti pour Python 3.7 et supérieur!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

Ce qui précède utilise la compréhension du dictionnaire.

ici
la source
2

vérifier d'abord si la clé existe déjà

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

alors vous pouvez ajouter la nouvelle clé et la nouvelle valeur

Agus Mathew
la source
0

ajouter une clé de dictionnaire, une classe de valeur.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)
Susan
la source