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

3113

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

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

3
  • 48
    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 19/12/18 a las 13:17
  • Utilice la respuesta aceptada: d ['mynewkey'] = 'mynewvalue' o puede usar val = d.setdefault ('mynewkey', 'mynewvalue')Ol' Dawg 7 ene.20 a las 19:32
  • 2
    Si solo usa <dictionary> [<key>] = <value> y si la clave no existe, la clave se agregará automáticamente. Jyotirmay Kumar Jha 30 de diciembre de 2020 a las 5:23
3978

Crea un nuevo par clave / valor en un diccionario asignando un valor a esa clave

d = {'key': 'value'}
print(d)  # {'key': 'value'}

d['mynewkey'] = 'mynewvalue'

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

Si la clave no existe, se agrega y apunta a ese valor. Si existe, se sobrescribe el valor actual al que apunta.

6
  • 20
    ¿Cuál es la diferencia entre este y el .update()método? ¿Qué es mejor cuando? hegash 16/01/19 a las 19:14
  • 25
    @hegash la d[key]=valsintaxis ya que es más corta y puede manejar cualquier objeto como clave (siempre que sea hash), 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 13/02/19 a las 8:38
  • ¿Cómo puedo agregar un elemento en un dictado anidado? Como php$foo[ ] = [ . . . . ]Juan-Kabbali 28/04/20 a las 12:55
  • Por favor, ¿alguien puede explicar la diferencia entre esta respuesta y append (), por ejemplo: a_dict ["a"]. Append ("hola")Selfcontrol7 1 de febrero a las 10:26
  • 1
    ¿De acuerdo con If it exists, the current value it points to is overwritten.cómo puedo hacer que verifique elegantemente si la clave en la que estoy tratando de agregar información ya existe y luego generar una excepción? Kots 25 feb a las 9:19
1168

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.

5
  • 19
    esto es taaaan 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 dictado)Jean-François Fabre 1 de agosto de 2018 a las 21:42
  • 17
    @ Jean-FrançoisFabre Este es un código de ejemplo. Realmente no debería tratar las respuestas como si cubrieran todos los casos. Robert Brisita 27/03/19 a las 5:59
  • 2
    da la impresión errónea de que es la forma preferida de agregar una clave. Jean-François Fabre 27/03/19 a las 6:14
  • @ Jean-FrançoisFabre Dado que el orden 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 20 de ene. De 2020 a las 16:10
  • si crea otra clave como x[-1] = 44el -1valor al final también. De todos modos la respuesta ha sido editada y es mucho mejor ahora. La actualización con un diccionario es buena cuando es probable que contenga muchos elementos. Jean-François Fabre 20/01/20 a las 16:26
1145

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

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

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

Python 3.9+:

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

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

Crear un diccionario combinado sin modificar los originales

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

Python 3.5+:

Esto utiliza una nueva función llamada descompresión de diccionario .

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

Python 3.9+:

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

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

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

data = dict(zip(list_with_keys, list_with_values))
2
  • El operador "OR" |en 3.9 parece resolver mi problema con los dictados de Python que no tienen ningún patrón de construcción. WestCoastProjects 24 feb a las 15:56
  • Sería bueno mencionar para las diversas opciones de "actualizar una entrada", que los que usan "actualizar" tienen la sobrecarga de crear un diccionario temporal. kdb 28 de julio a las 7:55
162

"Is it possible to add a key to a Python dictionary after it has been created? It doesn't seem to have an .add() method."

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

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

my_dict = {}

Práctica recomendada 1: notación de subíndice

Para actualizar este diccionario con una clave y un valor nuevos, puede utilizar la notación de subíndice (consulte Mapeos 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 utilizando el updatemétodo . Es posible que dictestemos creando innecesariamente un extra aquí, por lo que esperamos que nuestro dictya se haya creado y provenga o se haya usado 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 legítimas de Python, no puede tener espacios o símbolos especiales o comenzar el nombre con un número, pero muchos consideran que esta es una forma más legible. para crear claves para un dictado, y aquí ciertamente evitamos crear un extra innecesario dict:

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

y my_dictes 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 dictque no debería usar, que usa el __setitem__método. A continuación, se muestra un ejemplo de cómo se puede usar el __setitem__método para agregar un par clave-valor a a 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 usar __setitem__. Hacer lo Pythonic, es decir, usar el lenguaje de la forma en que se pretendía usar, generalmente es más legible y computacionalmente eficiente.

1
  • 1
    La diferencia es bastante menos marcada en 2020 (en mi máquina, subíndice de 1,35 ms frente a 2 ms para d.__setitem__), aunque la conclusión (y especialmente la última frase) sigue siendo sólida. Sacar la búsqueda del nombre del método del bucle redujo el tiempo a aproximadamente 1,65 ms; la diferencia restante probablemente se deba en gran parte a la inevitable sobrecarga del mecanismo de llamada de Python. holdenweb 5 feb.20 a las 13:41
110
dictionary[key] = value
0
60

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)

Producción:

{'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.

2
  • 15
    esto es irrelevante para la pregunta hecha ya que la mayoría de los comentarios en las páginas del manual de php.net ...Erik Kaplun 1 de junio de 2012 a las 21:05
  • 2
    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 27 dic 2017 a las 16:07
54

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

d.__setitem__(key, value)

De hecho, definir __getitem__y __setitem__métodos es cómo puede hacer que su propia clase admita la sintaxis de corchetes. Consulte Dive Into Python, 5.6. Métodos de clases especiales .

5
  • 23
    Me resultaría extremadamente difícil programar con Python sin las teclas de corchete en mi teclado. Bobort 27 oct 2016 a las 14:10
  • 2
    Esta fue la única forma que pude encontrar para establecer valores de diccionario dentro de una lista de comprensión. graciaschris stevens 18 de mayo de 2018 a las 13:29
  • 3
    @chrisstevens si desea 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 13/09/18 a las 22:45
  • 1
    Curioso ... ¿es esto común (es decir, los corchetes faltantes)? Aleister Tanek Javas Mraz 13/08/19 a las 16:47
  • @chrisstevens @JeremyLogan ¿Por qué usar una comprensión de lista cuando puede usar una comprensión de dictados? {v: k for k, v in my_dict.items() if <some_conditional_check>}ingyhere 20/01/20 a las 16:22
40

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

Esta popular pregunta aborda los métodos funcionales de fusionar diccionarios ay 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 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' )
2
  • 8
    Interesante comentario sobre el primer método del BDFL de Python ( aquí ). Brent Bradburn 17 de agosto de 2013 a las 23:09
  • 1
    c = dict( a, **{'d':'dog'} )sería mejor escrito como c = dict(a, d='dog'), siempre que las claves se conozcan y no se calculen. holdenweb 5 feb.20 a las 13:51
23

Supongamos que quiere vivir en el mundo inmutable y no quiere modificar el original, sino crear uno nuevo dictque sea el resultado de agregar una nueva clave al original.

En Python 3.5+ puede 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 agregar al original). Encuentro esta 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: ¿Qué significa "**" en la expresión "dict (d1, ** d2)"?

2
  • 3
    En una larga conversación con un colega mío de programación pro-funcional, se planteó 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 ocasiones en las que favorecerá un enfoque menos funcional para una mejor legibilidad. campeterson 30 de enero de 2018 a las 17:05
  • 6
    No podemos prever qué subconjunto del lenguaje Python conocen nuestros lectores, por lo que es justo suponer que conocen el lenguaje completo, por lo que buscan en los documentos las partes que no conocen. Gabriel 7 mar. 18 a las 20:56
21

También está el de nombre extraño, de comportamiento extraño y, sin embargo, útil 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
7

Si no está uniendo dos diccionarios, pero 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.

0
6

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 utilizar el constructor de diccionario y la expansión implícita para reconstruir un diccionario. Además, curiosamente, este método se puede utilizar 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á usando la comprensión del diccionario.

4

Primero para verificar si la clave ya existe:

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

Luego, puede agregar la nueva clave y valor.

4

Puede utilizar corchetes:

my_dict = {}
my_dict["key"] = "value"

O puede usar el método .update () :

my_another_dict = {"key": "value"}
my_dict = {}
my_dict.update(my_another_dict)
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 subclass that calls a factory function to supply missing values

Esto es particularmente útil si trabaja con diccionarios que siempre constan de 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 se usa dentro de 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 tal vez se vea algo como:

# 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 utilizar con tipos de datos complejos como listy set:

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

Agregar un elemento inicializa automáticamente la lista.

3

¡Aquí tienes una forma fácil!

your_dict = {}
your_dict['someKey'] = 'someValue'

Esto agregará un nuevo key: valuepar en el your_dictdiccionario con key = someKeyyvalue = somevalue

También puede utilizar esta forma para actualizar el valor de la clave somekeysi ya existe en el your_dict.

4
  • 3
    ¡esto funcionó en 2001 también! Boris 12 de febrero a las 9:13
  • Solo quería dejarlo en claro, ya que las cosas cambian mucho de vez en cuando, especialmente en la programaciónIrfan wani 12 feb a las 9:40
  • Irfan, va en contra de las convenciones al afirmar "en 2021": es un uso generalizado en SOF decir eso solo si las cosas son realmente diferentes a las del pasado. WestCoastProjects 24 feb a las 15:54
  • Eliminó la línea. Y lo siento por esto. Irfan wani 24 feb a las 16:11
2

Agregue una clase de diccionario (clave, 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)
1
your_dict = {}

Para agregar una nueva clave:

  1. your_dict[key]=value

  2. your_dict.update(key=value)