¿Añadir nuevas claves a un diccionario?

¿Es posible agregar una clave a un diccionario de Python después de que se haya creado? No parece tener un método .add() .

 d = {'key':'value'} print(d) # {'key': 'value'} d['mynewkey'] = 'mynewvalue' print(d) # {'mynewkey': 'mynewvalue', 'key': 'value'} 
 >>> x = {1:2} >>> print x {1: 2} >>> x.update({3:4}) >>> print x {1: 2, 3: 4} 

Tengo ganas de consolidar información sobre los diccionarios de Python:

Creando un diccionario vacío

 data = {} # OR data = dict() 

Creando un diccionario con valores iniciales.

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

Inserción / Actualización de un solo valor

 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) 

Insertando / Actualizando múltiples valores

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

Creando un diccionario fusionado sin modificar originales

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

Eliminar elementos en el diccionario

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

Compruebe si una clave ya está en el diccionario

 key in data 

Iterar a través de pares en un diccionario

 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 

Crear un diccionario a partir de 2 listas

 data = dict(zip(list_with_keys, list_with_values)) 

¡Siéntase libre de agregar más!

Sí, es bastante fácil. Solo haz lo siguiente:

 dict["key"] = "value" 

“¿Es posible agregar una clave a un diccionario de Python después de que se haya creado? No parece tener un método .add ()”.

Sí, es posible, y tiene un método que implementa esto, pero no desea utilizarlo directamente.

Para demostrar cómo y cómo no usarlo, vamos a crear un dict vacío con el literal de dict, {} :

 my_dict = {} 

Mejor práctica 1: notación de subíndices

Para actualizar este dictado con una sola clave y valor nuevos, puede usar la notación de subíndices (vea Asignaciones aquí) que proporciona la asignación de elementos:

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

my_dict es ahora:

 {'new key': 'new value'} 

Mejor práctica 2: el método de update – 2 maneras

También podemos actualizar el dict con múltiples valores de manera eficiente utilizando el método de update . Es posible que estemos creando innecesariamente un dict adicional aquí, por lo que esperamos que nuestro dict ya haya sido creado y provenga o haya sido utilizado para otro propósito:

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

my_dict es ahora:

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

Otra forma eficiente de hacer esto con el método de actualización es con argumentos de palabras clave, pero como tienen que ser palabras de Python legítimas, no puede tener espacios o símbolos especiales o comenzar el nombre con un número, pero muchos consideran que es una forma más fácil de leer. para crear claves para un dict, y aquí ciertamente evitamos crear un dict innecesario adicional:

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

y my_dict es ahora:

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

Así que ahora hemos cubierto tres formas Pythonic de actualizar un dict .


Método mágico, __setitem__ , y por qué debe evitarse

Hay otra forma de actualizar un dict que no debe usar, que usa el método __setitem__ . Este es un ejemplo de cómo se podría usar el método __setitem__ para agregar un par clave-valor a un dict , y una demostración del bajo rendimiento de usarlo:

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

Así que vemos que usar la notación de subíndices es en realidad mucho más rápido que usar __setitem__ . Hacer lo Pythonic, es decir, usar el lenguaje en la forma en que fue pensado para ser usado, generalmente es más legible y computacionalmente eficiente.

 dictionary[key] = value 

Si desea agregar un diccionario dentro de un diccionario, puede hacerlo de esta manera.

Ejemplo: agregue una nueva entrada a su diccionario y sub diccionario

 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) 

Salida:

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

NOTA: Python requiere que primero agregues un sub

 dictionary["dictionary_within_a_dictionary"] = {} 

antes de añadir entradas.

La syntax ortodoxa es d[key] = value , pero si a su teclado le faltan las teclas del corchete, podría hacerlo:

 d.__setitem__(key, value) 

De hecho, definir los métodos __getitem__ y __setitem__ es cómo puede hacer que su propia clase admita la syntax de corchete. Consulte http://www.diveintopython.net/object_oriented_framework/special_class_methods.html

puedes crear uno

 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) 

da

 >>> {'apples': 6, 'bananas': 3} 

Esta pregunta popular aborda los métodos funcionales de combinar diccionarios a y b .

Estos son algunos de los métodos más sencillos (probados 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() ) 

Nota: el primer método anterior solo funciona si las claves en b son cadenas.

Para agregar o modificar un solo elemento , el diccionario b contendría solo ese elemento …

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

Esto es equivalente a …

 def functional_dict_add( dictionary, key, value ): temp = dictionary.copy() temp[key] = value return temp c = functional_dict_add( a, 'd', 'dog' ) 

Supongamos que desea vivir en el mundo inmutable y NO desea modificar el original, sino que desea crear un nuevo dict que es el resultado de agregar una nueva clave al original.

En Python 3.5+ puedes hacer:

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

El equivalente de Python 2 es:

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

Después de cualquiera de estos:

params sigue siendo igual a {'a': 1, 'b': 2}

y

new_params es igual a {'a': 1, 'b': 2, 'c': 3}

Habrá ocasiones en las que no desee modificar el original (solo desea el resultado de agregarlo al original). Me parece una alternativa refrescante a lo siguiente:

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

o

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

Referencia: https://stackoverflow.com/a/2255892/514866

Tantas respuestas y aún así, todo el mundo se olvidó de los nombres extraños, de comportamiento extraño y, sin embargo, todavía son útiles dict.setdefault()

Esta

 value = my_dict.setdefault(key, default) 

básicamente solo hace esto:

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

p.ej

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

Se puede hacer mediante dict.update(Iterable_Sequence of key:value)

Ejemplo:

 wordFreqDic.update( {'before' : 23} ) 

Si no se une a dos diccionarios, pero agrega nuevos pares clave-valor a un diccionario, entonces usar la notación de subíndices parece ser la mejor manera.

 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 

Sin embargo, si desea agregar, por ejemplo, miles de nuevos pares clave-valor, debe considerar el uso del método update() .

Primero para comprobar si la clave ya existe

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

A continuación, puede agregar la nueva clave y valor