¿Cómo agrego una clave a un diccionario existente? No tiene .add()método.

respuesta

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.

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.

Tengo ganas de consolidar información sobre los diccionarios de 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'

Pitón 3.9+:

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

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

Creación de un diccionario fusionado sin modificar los originales

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

Pitón 3.5+:

Esto utiliza una nueva característica llamada desempaquetado de diccionario .

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

Pitón 3.9+:

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

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

Eliminación de 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

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

data = dict(zip(list_with_keys, list_with_values))

"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 cómo no usarlo, creemos un dict vacío con el literal dict {}:

my_dict = {}

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

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

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

my_dictes 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 usando el updatemétodo . Es posible que estemos creando un extra dictaquí innecesariamente, por lo que esperamos que el nuestro dictya se haya creado y provenga o se haya utilizado para otro propósito:

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

my_dictes 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 es 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_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 Pythonic de actualizar un archivo dict.


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

Hay otra forma de actualizar un archivo dictque no debe usar, que usa el __setitem__método. Aquí hay un ejemplo de cómo se 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 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 que se usara, 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 subdiccionario

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.

La sintaxis convencional es d[key] = value, pero si a su teclado le faltan las teclas de corchetes, también podría 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 Inmersión en Python, 5.6. Métodos de clases especiales .

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 métodos funcionalesa para fusionar diccionarios y archivos 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' )

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

paramssigue siendo igual a{'a': 1, 'b': 2}

y

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

Habrá momentos en los que no desee modificar el original (solo desea el resultado de agregar 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: ¿Qué significa `**` en la expresión `dict(d1, **d2)`?

También está el nombre extraño, el comportamiento extraño y, sin embargo, aún útil dict.setdefault().

Este

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

Hay dos formas de actualizar un diccionario:

  1. Utilice la notación de corchetes ( [])

    my_dict = {}
    my_dict['key'] = 'value'
    
  2. Usa el update()método

    my_dict = {}
    my_dict.update({'key': 'value'})
    

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

This question has already been answered ad nauseam, but since my comment gained a lot of traction, here it is as an answer:

Agregar nuevas claves sin actualizar el dict existente

Si está tratando de descubrir cómo agregar una clave y devolver un nuevo diccionario (sin modificar el existente), puede hacerlo utilizando las técnicas a continuación.

pitón >= 3.5

new_dict = {**mydict, 'new_key': new_val}

pitón <3.5

new_dict = dict(mydict, new_key=new_val)

Tenga en cuenta que con este enfoque, su clave deberá seguir las reglas de los nombres de identificadores válidos en python.

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 diccionarios y la expansión implícita para reconstruir un diccionario. Además, curiosamente, este método se puede usar 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.

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.

your_dict = {}

Para agregar una nueva clave:

  1. your_dict[key]=value

  2. your_dict.update(key=value)

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)

¡Aquí hay una manera 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 usar esta forma de actualizar el valor de la clave somekeysi ya existe en el archivo your_dict.

Existe un método de actualización en la clase dict que debería funcionar para usted.

Considerando:

# dictionary = {"key":"value"}

Pero sin ningún método, puede agregar una clave simplemente creando un nuevo valor como la línea a continuación:

dictionary['newkey'] = 'newvalue'

o usando la actualización https://www.python.org/dev/peps/pep-0584/#dict-update

dictionary.update({'newkey':'newvalue'})

Creo que también sería útil señalar el collectionsmódulo de Python que consta de muchas subclases y contenedores de diccionario ú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 está trabajando 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 el valor inicial del diccionario (a menudo se usa 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 intenta 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 parecería 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 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.

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)

Puede crear un nuevo par de clave y valor como este:

my_dictionary = {"key1" : "value1"}
my_dictionary["key2"] = "value2"

Para cambiar "key1" o "value2" puedes hacer lo mismo, así:

my_dictionary = {"key1" : "value1"}
my_dictionary["key2"] = "value2"

my_dictionary["key1"] = "value1_revised"