Python: compruebe si la clave existe en el diccionario

En este tutorial, repasaremos ejemplos sobre cómo verificar si existe una clave en un diccionario en Python. Repasaremos los enfoques más populares y de nicho y haremos una comparación de rendimiento.

Introducción

El diccionario (también conocido como 'mapa', 'hash' o 'matriz asociativa') es un contenedor integrado de Python que almacena elementos como un par clave-valor.

Al igual que otros contenedores tienen indexación numérica, aquí usamos claves como índices. Las claves pueden ser valores numéricos o de cadena. Sin embargo, ninguna secuencia u objeto mutable se puede usar como clave, como una lista.

En este artículo, veremos cómo comprobar si existe una clave en un diccionario en Python.

En los ejemplos, usaremos este diccionario fruits_dict:

1
fruits_dict = dict(apple= 1, mango= 3, banana= 4)
1
{'apple': 1, 'banana': 4, 'mango': 3}

Comprobar si la clave existe usando el operador in

La forma más sencilla de comprobar si existe una clave en un diccionario es utilizar el operador in. Es un operador especial usado para evaluar la pertenencia de un valor.

Aquí se evaluará como “Verdadero” si la clave existe o como “Falso” si no existe:

1
2
3
4
5
6
key = 'orange'

if key in fruits_dict:
    print('Key Found')
else:
    print('Key not found')

Ahora, como no tenemos una naranja en nuestro diccionario, este es el resultado:

1
Key not found

Este es el enfoque deseado y preferido por la mayoría de los desarrolladores. Bajo el capó, utiliza la función __contains__() para verificar si una clave dada está en un diccionario o no.

Comprobar si la clave existe usando get()

La función get() acepta una clave y un valor opcional que se devolverá si no se encuentra la clave. Por defecto, este valor opcional es Ninguno. Podemos intentar obtener una clave, y si el valor devuelto es Ninguno, eso significa que no está presente en el diccionario:

1
2
3
4
5
6
key = 'orange'

if fruits_dict.get(key) == None:
    print('Key not found')
else:
    print('Key found') 

Esto resulta en:

1
Key not found

Comprobar si la clave existe usando keys()

La función keys() devuelve las claves de nuestro diccionario como una secuencia:

1
fruits_dict.keys()

Esta secuencia contiene:

1
dict_keys(['apple', 'mango', 'banana'])

Usando esta secuencia, podemos verificar si la clave está presente. Puedes hacer esto a través de un bucle, o mejor aún, usa el operador in:

1
2
3
4
5
6
key = 'orange'

if key in fruits_dict.keys():
    print('Key found')
else:
    print('Key not found')

Esto también resulta en:

1
Key not found

Comprobar si la clave existe usando has_key()

En lugar de obtener manualmente las claves y verificar si el valor que estamos buscando está presente, podemos usar la función abreviada has_key():

1
2
3
4
5
6
key = 'orange'

if fruits_dict.has_key(key):
    print('Key found')
else:
    print('Key not found')

Devuelve Verdadero o Falso, según la presencia de la clave. Este código genera:

1
Key not found

Manejo de la excepción 'KeyError'

Una forma interesante de evitar problemas con una clave que no existe o, en otras palabras, comprobar si una clave existe en nuestro diccionario o no, es usar las cláusulas try y except para manejar la excepción KeyError.

La siguiente excepción surge cada vez que nuestro programa no puede ubicar la clave respectiva en el diccionario.

Es una forma simple, elegante y rápida de manejar la búsqueda de claves:

1
2
3
4
try:
    fruits_dict[key]
except KeyError as err:
    print('Key not found')

Este enfoque, aunque puede parecer poco intuitivo, en realidad es significativamente más rápido que otros enfoques que hemos cubierto hasta ahora.

Nota: Tenga en cuenta que las excepciones no deben usarse para alterar el flujo de código o para implementar la lógica. Disparan muy rápido, pero recuperarse de ellos es muy lento. Este enfoque no debe ser favorecido sobre otros enfoques, cuando sea posible.

Comparemos el rendimiento de ellos para tener una mejor idea de qué tan rápido pueden ejecutarse.

Comparación de rendimiento {#comparación de rendimiento}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import timeit

code_setup = """
key = 'orange'
fruits_dict = dict(apple= 1, mango= 3, banana= 4)
"""

code_1 = """
if key in fruits_dict:
  # print('Key Found')
  pass
else:
  # print('Key not found')
  pass 
"""

code_2 = """
if fruits_dict.get(key):
  # print('Key found')
  pass
else:
  # print('Key not found')
  pass 
"""

code_3 = """
if fruits_dict.__contains__(key):
  # print('Key found')
  pass
else:
  # print('Key not found')
  pass  
"""

code_4 = """
try:
  # fruits_dict[key]
  pass
except KeyError as err:
  # print('Key not found')
  pass 
"""
  
code_5 = """
if key in fruits_dict.keys():
  # print('Key found')
  pass
else:
  # print('Key not found')
  pass 
"""

print('Time of code_1: ', timeit.timeit(setup = code_setup , stmt= code_1, number= 10000000))
print('Time of code_2: ', timeit.timeit(setup = code_setup , stmt= code_2, number= 10000000))
print('Time of code_3: ', timeit.timeit(setup = code_setup , stmt= code_3, number= 10000000))
print('Time of code_4: ', timeit.timeit(setup = code_setup , stmt= code_4, number= 10000000))
print('Time of code_5: ', timeit.timeit(setup = code_setup , stmt= code_5, number= 10000000))

Esto da como resultado:

1
2
3
4
5
Time of code_1:  0.2753713619995324
Time of code_2:  0.8163219139996727
Time of code_3:  0.5563563220002834
Time of code_4:  0.1561058730003424
Time of code_5:  0.7869278369998938

La opción y el enfoque más populares, de usar el operador in es bastante rápido, y también es el enfoque previsto para resolver este problema.

Conclusión

En este artículo, discutimos varias formas de verificar si una clave existe en nuestro diccionario o no. Luego hicimos una comparación de rendimiento.

Licensed under CC BY-NC-SA 4.0