¿Cómo puedo agregar nuevas claves a un diccionario?


2623

¿Es posible agregar una clave a un diccionario de Python después de que se haya creado?

No parece tener un .add()método.


25
Si está aquí tratando de encontrar la manera de añadir una clave y devuelve un nuevo diccionario, se puede hacer esto en python3.5 +: {**mydict, 'new_key': new_val}.
cs95

Utilice la respuesta aceptada: d ['mynewkey'] = 'mynewvalue' o podría usar val = d.setdefault ('mynewkey', 'mynewvalue')
Ol 'Dawg

Respuestas:


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

108
La explicación es: crea un nuevo par clave \ valor en un diccionario asignando un valor a esa clave. Si la clave no existe, se agrega y apunta a ese valor. Si existe, se sobrescribe el valor actual al que apunta.
R. Navega

99
¿Cuál es la diferencia entre este y el .update()método? ¿Cuál es mejor cuando?
hegash

14
@hegash la d[key]=valsintaxis, ya que es más corta y puede manejar cualquier objeto como clave (siempre que sea hashable), y solo establece un valor, mientras que .update(key1=val1, key2=val2)es mejor si desea establecer varios valores al mismo tiempo, siempre que las claves son cadenas (ya que los kwargs se convierten en cadenas). dict.updatetambién puede tomar otro diccionario, pero personalmente prefiero no crear explícitamente un nuevo diccionario para actualizar otro.
bgusach

pruébalo, aquí hay un ejemplo: repl.it/@SmaMa/Add-key-to-dict
Sma Ma

¿Cómo puedo agregar un elemento en un dict anidado? Como php$foo[ ] = [ . . . . ]
Juan-Kabbali

1044

Para agregar varias claves simultáneamente, use 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}

Para agregar una sola clave, la respuesta aceptada tiene menos sobrecarga computacional.


13
Esto es muy ineficiente para crear un diccionario solo para actualizar una clave. Haga esto solo si tiene más de 1 clave (puede haber un umbral por encima del cual es mejor crear un dict)
Jean-François Fabre

10
@ Jean-FrançoisFabre Este es un código de ejemplo. Realmente no debes tratar las respuestas como si cubrieran todos los casos.
Robert Brisita

1
da la impresión equivocada de que es la forma preferida de agregar una clave.
Jean-François Fabre

@ Jean-FrançoisFabre Dado que el pedido de dict está garantizado en Python 3.7+ (y se proporciona en 3.6+) , esta puede ser una forma preferida de agregar una sola clave cuando el orden es importante .
ingyhere

si creas otra clave como x[-1] = 44el -1valor también está al final. De todos modos la respuesta ha sido editada y ahora es mucho mejor. Actualizar con un diccionario es bueno cuando es probable que contenga muchos elementos.
Jean-François Fabre

930

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

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

Crea un diccionario a partir de dos listas

data = dict(zip(list_with_keys, list_with_values))

Nuevo en Python 3.5

Crear un diccionario combinado sin modificar originales:

Esto utiliza un nuevo featrue llamado diccionario desempaquetado .

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

Nuevo en Python 3.9

Actualizar o agregar valores para un diccionario existente

El operador de actualización |= ahora funciona para los diccionarios:

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

Crear un diccionario combinado sin modificar originales

El operador de combinación | ahora funciona para los diccionarios:

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

¡Siéntase libre de agregar más!


145

"¿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 literal dict {}:

my_dict = {}

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

Para actualizar este dict con una sola clave y valor nuevos, puede usar la notación de subíndice (consulte 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 updatemétodo - 2 formas

También podemos actualizar el dict con múltiples valores de manera eficiente también mediante el updatemétodo . Es posible que dictestemos creando innecesariamente un extra aquí, por lo que esperamos que el nuestro dictya 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 dado que tienen que ser palabras legítimas de Python, 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 legible para crear claves para un dict, y aquí ciertamente evitamos crear un innecesario adicional dict:

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

y my_dictahora es:

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

Así que ahora hemos cubierto tres formas pitónicas de actualizar a dict.


Método mágico __setitem__y por qué debería evitarse

Hay otra forma de actualizar una dictque no deberías usar, que usa el __setitem__método. Aquí hay un ejemplo de cómo se podría usar el __setitem__método para agregar un par clave-valor a un dict, y una demostración del bajo rendimiento de su uso:

>>> 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 de subíndice es en realidad mucho más rápido que usarlo __setitem__. Hacer lo Pythonic, es decir, usar el lenguaje de la manera en que se pretendía usar, generalmente es más legible y computacionalmente eficiente.


1
La diferencia es bastante menos marcada en 2020 (en mi máquina, suscripción de 1,35 ms frente a 2 ms d.__setitem__), aunque la conclusión (y especialmente la última oración) sigue siendo sólida. Levantar la búsqueda del nombre del método fuera del ciclo redujo el tiempo a aproximadamente 1.65 ms; la diferencia restante probablemente se deba en gran medida a la inevitable sobrecarga del mecanismo de llamada de Python.
holdenweb


58

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.


13
Esto es tan irrelevante para la pregunta formulada como la mayoría de los comentarios en las páginas del manual de php.net ...
Erik Kaplun

2
No hay nada que te impida hacer esto en una línea: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}(o si dictionaryya es un dict, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})
Chris

43

La sintaxis ortodoxa es d[key] = value, pero si a su teclado le faltan las teclas de corchetes, puede hacer:

d.__setitem__(key, value)

De hecho, definiendo __getitem__y __setitem__métodos es cómo puede hacer que su propia clase admita la sintaxis de corchetes. Ver https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php


16
Me resultaría extremadamente difícil programar con Python sin las teclas de soporte en mi teclado.
Bobort

2
Esta fue la única forma que pude encontrar para establecer valores de diccionario dentro de una lista de comprensión. Gracias
chris stevens

3
@chrisstevens si quieres establecer un valor en una comprensión, un truco que he usado es [a for a in my_dict if my_dict.update({'a': 1}) is None].
Jeremy Logan

Curioso ... ¿esto es común (es decir, faltan corchetes)?
Aleister Tanek Javas Mraz

@chrisstevens @JeremyLogan ¿Por qué usar una lista de comprensión cuando puedes usar una comprensión dict? {v: k for k, v in my_dict.items() if <some_conditional_check>}
ingyhere

36

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}

31

Esta popular pregunta aborda métodos funcionales de fusión de diccionarios ay 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 bson cadenas.

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

8
Comentario interesante sobre el primer método del BDFL de Python ( aquí ).
nobar

c = dict( a, **{'d':'dog'} )sería mejor escribirlo c = dict(a, d='dog'), siempre que las claves sean conocidas y no se calculen.
holdenweb

21

Supongamos que desea vivir en el mundo inmutable y NO desea modificar el original, pero desea crear uno nuevo dictque sea 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 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


2
En una larga conversación con un colega de programación mía profesional, surgió un buen punto. Una desventaja del enfoque anterior es que si alguien que lee el código no está familiarizado con **Python (muchos no lo están), entonces no será obvio lo que está sucediendo. Hay momentos en que favorecerá un enfoque menos funcional para una mejor legibilidad.
campeterson

55
No podemos prever qué subconjunto del lenguaje Python conocen nuestros lectores, por lo que es justo suponer que conocen todo el lenguaje, por lo que buscan en los documentos las partes que no conocen.
Gabriel

17

Tantas respuestas y aún así todos se olvidaron de los nombres extraños, de comportamiento extraño, y aún así ú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

5

Si no está uniendo dos diccionarios, pero está agregando nuevos pares clave-valor a un diccionario, entonces usar la notación de subíndice 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, debería considerar usar el update()método.


3

Creo que también sería útil señalar el collectionsmódulo de Python que consta de muchas subclases de diccionario y envoltorios útiles que simplifican la adición y modificación de tipos de datos en un diccionario , específicamente defaultdict:

dict subclase que llama a una función de fábrica para suministrar valores faltantes

Esto es particularmente útil si está trabajando con diccionarios que siempre consisten en los mismos tipos de datos o estructuras, por ejemplo, un diccionario de listas.

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

Si la clave aún no existe, defaultdictasigna el valor dado (en nuestro caso 10) como valor inicial al diccionario (a menudo utilizado dentro de los bucles). Por lo tanto, esta operación hace dos cosas: agrega una nueva clave a un diccionario (según la pregunta) y asigna el valor si la clave aún no existe. Con el diccionario estándar, esto habría generado un error ya que la +=operación está intentando acceder a un valor que aún no existe:

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

Sin el uso de defaultdict, la cantidad de código para agregar un nuevo elemento sería mucho mayor y quizás se parece a:

# 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

defaultdicttambién se puede usar con tipos de datos complejos como listy set:

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

Agregar un elemento automáticamente inicializa la lista.


3

Aquí hay otra forma que no vi aquí:

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

Puede usar el constructor de diccionario y la expansión implícita para reconstruir un diccionario. Además, curiosamente, este método puede usarse para controlar el orden posicional durante la construcción del diccionario ( posterior a Python 3.6 ). De hecho, ¡el orden de inserción está garantizado para Python 3.7 y superior!

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

Lo anterior está utilizando la comprensión del diccionario.


2

primero para verificar si la clave ya existe

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

entonces puede agregar la nueva clave y valor


0

agregar clave de diccionario, clase de valor.

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)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.