Pregunta Agregar nuevas claves a un diccionario?


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


1904
2018-06-21 22:07


origen


Respuestas:


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

2510
2018-06-21 22:09



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

>>> x.update({3:4})
>>> print x
{1: 2, 3: 4}

850
2017-07-22 14:48



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

Creando un diccionario vacío

data = {}
# OR
data = dict()

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

Insertar / actualizar 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)

Insertar / actualizar múltiples valores

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

Crear 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

Comprueba 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

Crea un diccionario a partir de 2 listas

data = dict(zip(list_with_keys, list_with_values))

¡Siéntase libre de agregar más!


583
2017-12-05 06:07



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

dict["key"] = "value"

132
2018-06-21 22:09



"¿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 usarlo directamente.

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

my_dict = {}

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

Para actualizar este dict con una sola nueva clave y valor, puede usar la notación del subíndice (ver 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 update método - 2 maneras

También podemos actualizar el dict con múltiples valores de manera eficiente y utilizando el update método. Podemos estar creando innecesariamente un extra dict aquí, así que esperamos que dict ya se ha creado y proviene de o se usó 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 palabra clave, pero dado que tienen que ser palabras de pitón legítimas, no puede tener espacios o símbolos especiales o comenzar el nombre con un número, pero muchos lo consideran una forma más legible para crear claves para un dict, y aquí ciertamente evitamos crear un extra innecesario dict:

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é debería evitarse

Hay otra forma de actualizar un dict que no deberías usar, que usa el __setitem__ método. Aquí hay un ejemplo de cómo uno puede usar el __setitem__ método 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

Entonces, vemos que usar la notación del subíndice es en realidad mucho más rápido que usar __setitem__. Hacer lo pitoniano, es decir, usar el lenguaje en la forma en que se pretendía usar, generalmente es más legible y computacionalmente eficiente.


105
2017-11-29 23:57



dictionary[key] = value

73
2018-06-21 22:08



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 agregue un sub

dictionary["dictionary_within_a_dictionary"] = {}

antes de agregar entradas.


44
2018-04-26 19:04



La sintaxis ortodoxa es d[key] = value, pero si su teclado no tiene las llaves de corchete cuadrado que podría hacer:

d.__setitem__(key, value)

De hecho, definiendo __getitem__ y __setitem__ métodos es cómo puede hacer que su propia clase soporte la sintaxis del corchete cuadrado. Ver http://www.diveintopython.net/object_oriented_framework/special_class_methods.html


31
2018-04-14 00:58



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}

25
2018-05-25 13:33



Esta pregunta popular direcciones funcional métodos de fusión de diccionarios a y b.

Estos son algunos de los métodos más directos (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 b son cuerdas.

Para agregar o modificar un solo elemento, el b diccionario 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' )

25
2017-08-17 23:04



data = {}
data['a'] = 'A'
data['b'] = 'B'

for key, value in data.iteritems():
    print "%s-%s" % (key, value)

resultados en

a-A
b-B

15
2017-12-05 06:26