Ajouter de nouvelles clés à un dictionnaire?
Est-il possible d'ajouter une clé à un dictionnaire Python après sa création? Il ne semble pas avoir de méthode .add().
d = {'key':'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'mynewkey': 'mynewvalue', 'key': 'value'}
Pour ajouter plusieurs clés simultanément:
>>> 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 l'ajout d'une clé unique, la réponse acceptée entraîne moins de temps système.
J'ai envie de consolider les informations sur les dictionnaires Python:
Créer un dictionnaire vide
data = {}
# OR
data = dict()
Création d'un dictionnaire avec les 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))}
Insérer/mettre à jour 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)
Insérer/mettre à jour plusieurs valeurs
data.update({'c':3,'d':4}) # Updates 'c' and adds 'd'
Création d'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érifier si une clé est déjà dans le dictionnaire
key in data
Itérer par 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éer un dictionnaire à partir de 2 listes
data = dict(Zip(list_with_keys, list_with_values))
Nouveau sur Python3
Création d'un dictionnaire fusionné sans modifier les originaux
data = {**data1, **data2, **data3}
Ne hésitez pas à ajouter plus!
Oui, c'est assez facile. Il suffit de faire ce qui suit:
dict["key"] = "value"
"Est-il possible d'ajouter une clé à un Python dictionnaire après sa création? Il ne semble pas avoir de méthode .add ()."
Oui, c'est possible, et il existe 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 permet l'affectation des éléments:
my_dict['new key'] = 'new value'
my_dict est maintenant:
{'new key': 'new value'}
Meilleure pratique 2: La méthode update - 2 façons
Nous pouvons également mettre à jour efficacement le dict avec plusieurs valeurs en utilisant la méthode update . Nous risquons de créer inutilement un dict supplémentaire ici; nous espérons donc que notre dict a 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'}
Un autre moyen efficace de procéder avec la méthode update consiste à utiliser des mots clés, mais comme ils doivent être des mots légitimes python, vous ne pouvez pas avoir d'espaces ou de symboles spéciaux, ni commencer le nom par un nombre. Considérez ceci comme un moyen plus lisible de créer des clés pour un dict, et ici nous évitons certainement de créer un nom supplémentaire inutile dict:
my_dict.update(foo='bar', foo2='baz')
et my_dict est maintenant:
{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value',
'foo': 'bar', 'foo2': 'baz'}
Nous avons donc maintenant présenté trois façons Pythonic de mettre à jour un dict.
Méthode magique, __setitem__, et pourquoi l’éviter
Il existe un autre moyen de mettre à jour un dict que vous ne devriez pas utiliser, qui utilise la méthode __setitem__. Voici un exemple d'utilisation de la méthode __setitem__ pour ajouter une paire clé-valeur à un dict, et une démonstration de la piètre performance 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 de __setitem__. Faire la chose Pythonic, c’est-à-dire utiliser le langage de la manière dont il était censé être utilisé, est généralement à la fois plus lisible et plus efficace en terme de calcul.
dictionary[key] = value
Si vous souhaitez ajouter un dictionnaire dans un dictionnaire, vous pouvez le faire de cette façon.
Exemple: Ajouter 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)
Sortie:
{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}
NOTE: 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 s'il manque les touches de crochets sur votre clavier, vous pouvez effectuer les opérations suivantes:
d.__setitem__(key, value)
En fait, définir les méthodes __getitem__ et __setitem__ vous permet de 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 adresse des méthodes fonctionnelles de fusion de dictionnaires a et 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 de b sont des chaînes.
Pour ajouter ou modifier un seul élément , le dictionnaire b ne contiendrait que cet élément ...
c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'
Ceci est équivalent à ...
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 souhaitiez vivre dans le monde immuable et que vous ne souhaitiez PAS modifier l'original, mais que vous souhaitiez créer une nouvelle dict résultant 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'une ou l'autre de ces choses:
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 au suivant:
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 encore tout le monde a oublié le nom étrange, bizarrement comporté, et pourtant toujours pratique dict.setdefault()
Cette
value = my_dict.setdefault(key, default)
fondamentalement juste fait 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
Vous pouvez le faire par dict.update(Iterable_Sequence of key:value)
Exemple:
wordFreqDic.update( {'before' : 23} )
Si vous ne rejoignez pas deux dictionnaires, mais que vous ajoutez de nouvelles paires clé-valeur à un dictionnaire, alors l'utilisation de la notation en indice semble être la meilleure solution.
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
Toutefois, si vous souhaitez ajouter, par exemple, des milliers de nouvelles paires clé-valeur, envisagez d'utiliser la méthode update().
d'abord pour vérifier 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 valeur
Je pense qu’il serait également utile de signaler le module collections de Python, constitué de nombreuses sous-classes de dictionnaire et wrappers utiles qui simplifient la addition et modification de types de données dans un dictionnaire , plus précisément defaultdict :
sous-classe dict qui appelle une fonction factory pour fournir les valeurs manquantes
Ceci est particulièrement utile si vous utilisez des dictionnaires contenant toujours les 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, defaultdict attribue la valeur donnée (dans notre cas, 10) comme valeur initiale au dictionnaire (souvent utilisée à l'intérieur des boucles). Cette opération a donc deux effets: it ajoute une nouvelle clé à un dictionnaire (comme dans le cas de la question), et attribue la valeur si la clé ne l’a pas encore été. exist. Avec le dictionnaire standard, cela aurait généré 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 permettant d'ajouter un nouvel élément serait beaucoup plus importante 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
defaultdict peut également être utilisé avec des types de données complexes tels que list et set:
>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})
L'ajout d'un élément initialise automatiquement la liste.