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

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

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

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.

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!

"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.

dictionary[key] = value

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.

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

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}

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

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

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

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.

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.

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.

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

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)