Eliminar un elemento de un diccionario

¿Hay alguna forma de eliminar un elemento de un diccionario en Python?

Además, ¿cómo puedo eliminar un elemento de un diccionario para devolver una copia (es decir, sin modificar el original)?

La deldeclaración elimina un elemento:

del d[key]

Sin embargo, esto muta el diccionario existente, por lo que el contenido del diccionario cambia para cualquier otra persona que tenga una referencia a la misma instancia. Para devolver un nuevo diccionario, haga una copia del diccionario:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

El dict()constructor hace una copia superficial . Para hacer una copia profunda, vea el copymódulo .

Tenga en cuenta que hacer una copia para cada dict del/ asignación / etc. significa que vas del tiempo constante al tiempo lineal, y también estás usando el espacio lineal. Para pequeños dictados, esto no es un problema. Pero si planea hacer muchas copias de grandes dictados, probablemente desee una estructura de datos diferente, como un HAMT (como se describe en esta respuesta ).

pop Muta el diccionario.

 >>> lol = {"hello": "gdbye"}
 >>> lol.pop("hello")
     'gdbye'
 >>> lol
     {}

Si desea conservar el original, simplemente puede copiarlo.

Creo que su solución es la mejor manera de hacerlo. Pero si desea otra solución, puede crear un nuevo diccionario utilizando las claves del diccionario anterior sin incluir la clave especificada, como esta:

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

La declaración del es lo que estás buscando. Si tiene un diccionario llamado foo con una clave llamada 'bar', puede eliminar 'bar' de foo de esta manera:

del foo['bar']

Tenga en cuenta que esto modifica permanentemente el diccionario que se está utilizando. Si desea conservar el diccionario original, deberá crear una copia de antemano:

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

La dictllamada hace una copia superficial. Si quieres una copia profunda, úsala copy.deepcopy.

Aquí hay un método que puede copiar y pegar, para su conveniencia:

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

Hay muchas respuestas agradables, pero quiero enfatizar una cosa.

Puede usar tanto el dict.pop()método como una deldeclaración más genérica para eliminar elementos de un diccionario. Ambos mutan el diccionario original, por lo que debe hacer una copia (consulte los detalles a continuación).

Y ambos aparecerán KeyErrorsi la clave que les está proporcionando no está presente en el diccionario:

key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove]  # Raises `KeyError: 'c'`

y

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove)  # Raises `KeyError: 'c'`

Tienes que ocuparte de esto:

capturando la excepción:

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    del d[key_to_remove]
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

y

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    d.pop(key_to_remove)
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

realizando una verificación:

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    del d[key_to_remove]

y

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    d.pop(key_to_remove)

pero pop()también hay una forma mucho más concisa: proporcione el valor de retorno predeterminado:

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None)  # No `KeyError` here

A menos que utilice pop()para obtener el valor de una clave que se eliminará, puede proporcionar cualquier cosa, no necesaria None. Aunque podría ser que usarlo delcon incheck es un poco más rápido debido a que pop()es una función con sus propias complicaciones que causan sobrecarga. Por lo general, no es el caso, por lo que pop()con el valor predeterminado es lo suficientemente bueno.

En cuanto a la pregunta principal, tendrá que hacer una copia de su diccionario, guardar el diccionario original y tener uno nuevo sin quitar la clave.

Algunas otras personas aquí sugieren hacer una copia completa (profunda) con copy.deepcopy(), que podría ser una exageración, una copia "normal" (superficial), usando copy.copy()o dict.copy(), podría ser suficiente. El diccionario mantiene una referencia al objeto como valor para una clave. Entonces, cuando elimina una clave de un diccionario, se elimina esta referencia, no el objeto al que se hace referencia. El objeto en sí puede ser eliminado más tarde automáticamente por el recolector de basura, si no hay otras referencias para él en la memoria. Hacer una copia profunda requiere más cálculos en comparación con una copia superficial, por lo que disminuye el rendimiento del código al hacer la copia, desperdiciando memoria y proporcionando más trabajo al GC, a veces una copia superficial es suficiente.

Sin embargo, si tiene objetos mutables como valores de diccionario y planea modificarlos más adelante en el diccionario devuelto sin la clave, debe hacer una copia profunda.

Con copia superficial:

def get_dict_wo_key(dictionary, key):
    """Returns a **shallow** copy of the dictionary without a key."""
    _dict = dictionary.copy()
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

Con copia profunda:

from copy import deepcopy


def get_dict_wo_key(dictionary, key):
    """Returns a **deep** copy of the dictionary without a key."""
    _dict = deepcopy(dictionary)
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

... ¿cómo puedo eliminar un elemento de un diccionario para devolver una copia (es decir, sin modificar el original)?

A dictes la estructura de datos incorrecta para usar para esto.

Claro, copiar el dict y el estallido de la copia funciona, y también lo hace construir un nuevo dict con una comprensión, pero toda esa copia lleva tiempo: ha reemplazado una operación de tiempo constante por una de tiempo lineal. Y todas esas copias vivas a la vez ocupan espacio: espacio lineal por copia.

Otras estructuras de datos, como los intentos de mapeo de matriz hash , están diseñados para este tipo de caso de uso: agregar o eliminar un elemento devuelve una copia en tiempo logarítmico, compartiendo la mayor parte de su almacenamiento con el original . ¹

Por supuesto que hay algunos inconvenientes. El rendimiento es logarítmico en lugar de constante (aunque con una base grande, generalmente 32-128). Y, si bien puede hacer que la API no mutante sea idéntica dict, la API "mutante" es obviamente diferente. Y, sobre todo, no hay baterías HAMT incluidas con Python. ²

La pyrsistentbiblioteca es una implementación bastante sólida de reemplazos dict basados ​​en HAMT (y varios otros tipos) para Python. Incluso tiene una ingeniosa API de evolución para portar código mutante existente a código persistente de la manera más fluida posible. Pero si desea ser explícito acerca de devolver copias en lugar de mutar, simplemente utilícelo de esta manera:

>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})

Eso d3 = d1.remove('a')es exactamente lo que pide la pregunta.

Si tiene estructuras de datos mutables como dicte listincrustadas en el pmap, aún tendrá problemas de alias: solo puede solucionarlo si se vuelve inmutable hasta el fondo, incrustando pmapsy pvectors.

_{1. Los HAMT también se han vuelto populares en lenguajes como Scala, Clojure, Haskell porque juegan muy bien con la programación sin bloqueo y la memoria transaccional de software, pero ninguno de los dos es muy relevante en Python.}

_{2. De hecho, no es un HAMT en el stdlib, que se utiliza en la ejecución de contextvars. El PEP retirado anteriormente explica por qué. Pero este es un detalle de implementación oculto de la biblioteca, no un tipo de colección pública.}

d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

Resultado: d = {1: 2, '2': 3}

Simplemente llame a del d ['clave'].

Sin embargo, en producción, siempre es una buena práctica verificar si existe 'clave' en d.

if 'key' in d:
    del d['key']

No, no hay otra manera que

def dictMinus(dct, val):
   copy = dct.copy()
   del copy[val]
   return copy

Sin embargo, a menudo crear copias de diccionarios ligeramente alterados probablemente no sea una buena idea porque generará demandas de memoria relativamente grandes. Por lo general, es mejor registrar el diccionario antiguo (si es necesario) y luego modificarlo.

# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)

>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

esto no hace ningún manejo de errores, asume que la clave está en el dict, es posible que desee verificar eso primero y raisesi no

Aquí un enfoque de diseño de nivel superior:

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

Estoy pasando el diccionario y la clave que quiero a mi función, valida si es un diccionario y si la clave está bien, y si ambos existen, elimina el valor del diccionario e imprime los sobrantes.

Salida: {'B': 55, 'A': 34}

¡Espero que ayude!

A continuación, el fragmento de código lo ayudará definitivamente, he agregado comentarios en cada línea que lo ayudarán a comprender el código.

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

o también puedes usar dict.pop ()

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

o el mejor enfoque es

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}

Aquí hay otra variación usando la comprensión de la lista:

original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}

El enfoque se basa en una respuesta de esta publicación: forma eficiente de eliminar claves con cadenas vacías de un dict

    species = {'HI': {'1': (1215.671, 0.41600000000000004),
  '10': (919.351, 0.0012),
  '1025': (1025.722, 0.0791),
  '11': (918.129, 0.0009199999999999999),
  '12': (917.181, 0.000723),
  '1215': (1215.671, 0.41600000000000004),
  '13': (916.429, 0.0005769999999999999),
  '14': (915.824, 0.000468),
  '15': (915.329, 0.00038500000000000003),
 'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}

El siguiente código hará una copia de dict speciesy eliminará elementos que no están entrans_HI

trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
    if transition not in trans_HI:
        species['HI'].pop(transition)