Python: cómo eliminar una clave de un diccionario

Aprendamos tres formas de eliminar pares clave-valor de un diccionario de Python: la función `pop()`, la palabra clave `del` y las comprensiones de dictado.

Introducción

En este artículo, veremos cómo eliminar claves de los diccionarios de Python. Esto se puede hacer con la función pop(), la palabra clave del y con comprensiones de dictados.

Eliminar una clave usando pop(key,d)

La función pop(key, d) elimina una clave de un diccionario y devuelve su valor. Se necesitan dos argumentos, se elimina la clave y se devuelve el valor opcional si no se encuentra la clave. Aquí hay un ejemplo de abrir un elemento con solo el argumento clave requerido:

1
2
3
4
5
my_dict = {1: "a", 2: "b"}
popped_value = my_dict.pop(1)

line = "The value removed from the dictionary of the key: 1 is {}"
print(line.format(popped_value))

Este fragmento de código devuelve el siguiente resultado:

1
The value removed from the dictionary of the key: 1 is a

Ahora, observe lo que sucede cuando intentamos eliminar una clave que no existe:

1
2
3
4
5
my_dict = {1: "a", 2: "b"}
popped_value = my_dict.pop(3)

line = "The value removed from the dictionary of the key: 3 is {}"
print(line.format(popped_value))

Esto genera un KeyError, como se esperaba, ya que no existe:

1
2
3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3

Si llama a pop() en una clave que no existe, Python devolverá un KeyError. Así que solo usa pop(key) si estás seguro de que la clave existe en el diccionario.

Si no está seguro de si la clave existe, coloque un valor para el segundo argumento opcional para pop(): el valor predeterminado. En lugar de arrojar un KeyError, devolverá ese valor.

El fragmento anterior se puede reescribir como:

1
2
3
4
5
my_dict = {1: "a", 2: "b"}
removed_value = my_dict.pop(3, None)

line = "The value removed from the dictionary of the key: 3 is {}"
print(line.format(removed_value))

Y ahora no arroja un error cuando lo ejecutamos:

1
The value removed from the dictionary of the key: 3 is None

Quitar una clave usando del dict[key]

Otra forma de eliminar una clave de un diccionario es a través de la palabra clave del. Esta palabra clave puede eliminar cualquier objeto. También puede eliminar un par clave-valor de un diccionario como este: del dict_name[clave]:

1
2
3
4
5
my_dict = {1: "a", 2: "b"}
del my_dict[1]

line = "The dictionary after deletion is {}"
print(line.format(my_dict))

El fragmento anterior devuelve el siguiente resultado, que denota el diccionario con solo los valores omitidos:

1
The dictionary after deletion is {2: 'b'}

A diferencia de pop(), no se devuelve ningún valor cuando se elimina. Si está buscando conservar la entrada de diccionario existente, puede encontrar que la siguiente sección le resultará útil.

Quitar múltiples claves de diccionario con comprensiones de dictados

Los métodos anteriores actualizan un diccionario en el lugar, lo que significa que se destruye el par clave-valor. Si es necesario conservar la clave original, podemos usar una función personalizada para hacerlo. En Python, se sabe comúnmente que podemos usar la comprensión de listas para crear una nueva lista basada en una existente. Podemos hacer lo mismo con diccionarios usando comprensiones de dictados.

Entonces, en lugar de eliminar valores en una lista, podemos usar una comprensión de dictado para crear un nuevo diccionario con una condición que excluya los valores que no queremos.

Tome el siguiente ejemplo donde creamos un nuevo diccionario que no tiene una clave de 1:

1
2
3
4
5
my_dict = {1: "a", 2: "b"}
my_dict2 = {k: v for k, v in my_dict.items() if k != 1}

line = "The new dictionary is {}"
print(line.format(my_dict2))

Este fragmento genera el siguiente resultado, imprimiendo el nuevo diccionario:

1
The new dictionary is {2: 'b'}

Tenga en cuenta que estamos creando un nuevo diccionario, agregando al uso de memoria de nuestro programa. Para diccionarios de mayor tamaño, si no excluimos muchos miembros, casi duplicamos la memoria utilizada para esos datos.

Eficiencia de la función de evaluación comparativa

Hemos observado tres métodos hasta ahora. Pero, ¿qué método es el más rápido entre los tres?

Vamos a crear un diccionario aleatorio en el que probaremos nuestros métodos. La siguiente función gen_random_dict(n) toma una lista como argumento y crea un diccionario con enteros aleatorios:

1
2
3
4
5
6
7
8
9
import random

def gen_random_dict(n):
    random.seed(0)
    mydict = {}
    for i in range(n):
        nmbr = random.randrange(1, n, 1)
        mydict[nmbr] = "value "+ str(nmbr)
    return mydict

En este mismo archivo, agreguemos algunas funciones que eliminan una clave en cada una de las formas que discutimos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# Remove a key using pop function
def remove_using_pop(dict_input):
    dict_input.pop(1)
    return None


# Remove a key using del keyword
def remove_using_del(dict_input):
    del dict_input[1]
    return None


# Remove a key using condition
def remove_using_condition(dict_input):
    return {k: v for k, v in dict_input.items() if k != 1}

Finalmente, agregue el siguiente código que usa el módulo timeit que mide el tiempo de ejecución de nuestro código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import timeit


if __name__ == "__main__":
    func_to_be_tested = "remove_using_pop(gen_random_dict(10000))"
    setup_stmt = "from __main__ import remove_using_pop, gen_random_dict"
    runtime1 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
    func_to_be_tested = "remove_using_del(gen_random_dict(10000))"
    setup_stmt = "from __main__ import remove_using_del, gen_random_dict"
    runtime2 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
    func_to_be_tested = "remove_using_condition(gen_random_dict(10000))"
    setup_stmt = "from __main__ import remove_using_condition, gen_random_dict"
    runtime3 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
    print("Runtime for removing key from Dict:")
    print("\t1) Using Pop: {}".format(str(runtime1)))
    print("\t2) Using Del: {}".format(str(runtime2)))
    print("\t3) Using Condition: {}".format(str(runtime3)))

Si bien los resultados pueden variar en su computadora, el patrón debe ser consistente. Aquí está el resultado que obtuvimos después de ejecutar este script:

1
2
3
4
Runtime for removing key from Dict:
        1) Using Pop: 0.015606499999194057
        2) Using Del: 0.01090950000070734
        3) Using Condition: 0.011443700001109391

El uso de la palabra clave del tiene una ventaja sobre el resto de los métodos. Aunque la diferencia horaria no parece ser muy dramática en diccionarios más pequeños. Sin embargo, tendrá un gran impacto cuando el tamaño del diccionario sea grande.

Conclusión

En este artículo, aprendimos tres formas en las que un par clave-valor puede eliminarse de un diccionario: pop(), del y dict comprehensions. Elegir el método correcto para el tamaño correcto del diccionario puede ayudar a disminuir el tiempo de ejecución del script y el uso de la memoria.