Compruebe si una clave dada ya existe en un diccionario

Quería probar si existe una clave en un diccionario antes de actualizar el valor de la clave. Escribí el siguiente código:

if 'key1' in dict.keys(): print "blah" else: print "boo" 

Creo que esta no es la mejor manera de lograr esta tarea. ¿Hay una mejor manera de probar una clave en el diccionario?

in es la forma prevista de probar la existencia de una clave en un dict .

 d = dict() for i in xrange(100): key = i % 10 if key in d: d[key] += 1 else: d[key] = 1 

Si desea un valor predeterminado, siempre puede usar dict.get() :

 d = dict() for i in xrange(100): key = i % 10 d[key] = d.get(key, 0) + 1 

… y si desea garantizar siempre un valor predeterminado para cualquier clave, puede usar defaultdict desde el módulo de collections , así:

 from collections import defaultdict d = defaultdict(lambda: 0) for i in xrange(100): d[i % 10] += 1 

… pero en general, la palabra clave es la mejor manera de hacerlo.

No tienes que llamar a las teclas:

 if 'key1' in dict: print "blah" else: print "boo" 

Eso será mucho más rápido, ya que utiliza el hash del diccionario en lugar de hacer una búsqueda lineal, lo que harían las claves de llamada.

Puede probar la presencia de una clave en un diccionario, usando la palabra clave in :

 d = {'a': 1, 'b': 2} 'a' in d # <== evaluates to True 'c' in d # <== evaluates to False 

Un uso común para verificar la existencia de una clave en un diccionario antes de mutarlo es inicializar por defecto el valor (por ejemplo, si sus valores son listas, por ejemplo, y quiere asegurarse de que haya una lista vacía a la que pueda agregar) al insertar el primer valor para una clave). En casos como estos, es posible que encuentre interesante el tipo collections.defaultdict() .

En el código anterior, también puede encontrar algunos usos de has_key() , un método obsoleto para verificar la existencia de claves en los diccionarios (solo use key_name in dict_name ).

Puedes acortar esto:

 if 'key1' in dict: ... 

Sin embargo, esto es en el mejor de los casos una mejora cosmética. ¿Por qué crees que esta no es la mejor manera?

Recomendaría usar el método setdefault lugar. Parece que va a hacer todo lo que quieras.

 >>> d = {'foo':'bar'} >>> q = d.setdefault('foo','baz') #Do not override the existing key >>> print q #The value takes what was originally in the dictionary bar >>> print d {'foo': 'bar'} >>> r = d.setdefault('baz',18) #baz was never in the dictionary >>> print r #Now r has the value supplied above 18 >>> print d #The dictionary's been updated {'foo': 'bar', 'baz': 18} 

Para obtener información adicional sobre la ejecución de la velocidad de los métodos propuestos de la respuesta aceptada (10m bucles):

  • 'key' in mydict tiempo transcurrido 1.07 seg
  • mydict.get('key') tiempo transcurrido 1.84 seg.
  • mydefaultdict['key'] tiempo transcurrido 1.07 seg.

Por lo tanto, se recomienda usar in o defaultdict contra get .

El diccionario en python tiene un método de obtención (‘clave’, predeterminado). Así que solo puede establecer un valor predeterminado en caso de que no haya una clave.

 values = {...} myValue = values.get('Key', None) 

¿Qué pasa con el uso de EAFP (más fácil pedir perdón que permiso):

 try: blah = dict["mykey"] # key exists in dict except KeyError: # key doesn't exist in dict 

Ver otras publicaciones de SO:

Usando try vs si está en python o

Comprobando la existencia de miembros en Python

Utilizando operador ternario:

 message = "blah" if 'key1' in dict else "booh" print(message) 

Para verificar puedes usar el método has_key()

 if dict.has_key('key1'): print "it is there" 

Si quieres un valor entonces puedes usar el método get()

 a = dict.get('key1', expeced_type) 

Si desea una tupla o lista o diccionario o cualquier cadena como valor predeterminado como valor de retorno, entonces use el método get()

 a = dict.get('key1', {}).get('key2', []) 

Las formas en que puede obtener los resultados son:

  • si your_dict.has_key (key) Eliminado en Python 3
  • si es clave en tu_dicto
  • prueba / excepto bloque

Lo que es mejor depende de 3 cosas:

  1. ¿El diccionario ‘normalmente tiene la clave’ o ‘normalmente no tiene la clave’?
  2. ¿Tiene la intención de utilizar condiciones como si … más … elseif … más?
  3. ¿Qué tan grande es el diccionario?

Leer más: http://paltman.com/try-except-performance-in-python-a-simple-test/

Uso de try / block en lugar de ‘in’ o ‘if’:

 try: my_dict_of_items[key_i_want_to_check] except KeyError: # Do the operation you wanted to do for "key not present in dict". else: # Do the operation you wanted to do with "key present in dict." 

Sólo un FYI añadiendo a Chris. B (mejor respuesta):

 d = defaultdict(int) 

Funciona también; la razón es que llamar a int() devuelve 0 que es lo que hace el valor defaultdict detrás de la escena (al construir un diccionario), de ahí el nombre “Función de fábrica” ​​en la documentación.

Puedes usar el método has_key ():

 if dict.has_key('xyz')==1: #update the value for the key else: pass 

O el método dict.get para establecer un valor predeterminado si no se encuentra:

 mydict = {"a": 5} print mydict["a"] #prints 5 print mydict["b"] #Throws KeyError: 'b' print mydict.get("a", 0) #prints 5 print mydict.get("b", 0) #prints 0 

print dict.get('key1', 'blah')

No imprimirá abucheos para los valores en el dict, pero logra el objective imprimiendo el valor de key1 para confirmar su existencia.

Para verificar si una clave dada existe en un diccionario, debe utilizar cualquiera de los siguientes métodos :

Enfoque Uno (trabajando en Python 3):

 def checkKey(dict, key): if key in dict.keys(): print("Key is here, ", end =" ") print("value =", dict[key]) else: print("Key isn't present.") 

Vamos a comprobarlo:

 dict = {'r': 30, 'g':59, 'b':11} key = 'b' checkKey(dict, key) key = 'a' checkKey(dict, key) 

Resultado del Approach One :

 # Key is here, value = 11 # Key isn't present. 

Enfoque Dos (trabajando en Python 3):

 def checkKey(dict, key): if key in dict: print("Key is here, ", end =" ") print("value =", dict[key]) else: print("Key isn't present.") 

Vamos a comprobarlo también:

 dict = {'x': 10, 'y':20, 'z':30} key = 'y' checkKey(dict, key) key = 'u' checkKey(dict, key) 

Resultado del Approach Two :

 # Key is here, value = 20 # Key isn't present. 

Enfoque tres (trabajando en Python 3):

 def checkKey(dict, key): if dict.has_key(key): print "Key is here, value =", dict[key] else: print "Key isn't present." 

Vamos a comprobarlo también:

 dict = {'u': 0, 'v':1, 'w':2} key = 'u' checkKey(dict, key) key = 'm' checkKey(dict, key) 

Resultado del Approach Three :

 # Key is here, value = 0 # Key isn't present. 

Espero que esto ayude.

El diccionario de Python tiene el método llamado __contains__ . Este método devolverá True si el diccionario tiene la clave; de ​​lo contrario, devolverá False.

  >>> temp = {} >>> help(temp.__contains__) Help on built-in function __contains__: __contains__(key, /) method of builtins.dict instance True if D has a key k, else False. 

Bien … Estará familiarizado con que buscar la existencia de un elemento en una lista o datos significa revisar todo (al menos para la lista desordenada, por ejemplo, dict.keys). Entonces, al usar Excepción y Errores que surgen normalmente, podemos evitar esa complejidad …

 d={1:'a',2:'b'} try: needed=d[3] print(needed) except: print("Key doesnt exist") 

La más sencilla es si sabe qué clave (nombre de clave) buscar:

 # suppose your dictionary is my_dict = {'foo': 1, 'bar': 2} # check if a key is there if 'key' in my_dict.keys(): # it will evaluates to true if that key is present otherwise false. # do something 

o también puedes hacerlo simplemente como:

 if 'key' in my_dict: # it will evaluates to true if that key is present otherwise false. # do something 

Yo uso el try / except ; si se lanza una excepción, entonces la clave no está presente en el diccionario. ejemplo:

 st = 'sdhfjaks' d = {} try: print d['st'] except Exception, e: print 'Key not in the dictionary' 

Puede usar for loop para ir en cada elemento al diccionario y obtener el nombre que desea encontrar en el diccionario, después de eso, verifique si existe o no de esa manera:

 dic={'first' : 12, 'second' : 123} For each in dic : If each == 'second': Print ('it is exist') else : print ('not exist') 

¿Por qué no usar el método has_key ()?

 a = {} a.has_key('b') => #False a['b'] = 8 a.has_key('b') => #True