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?

ines la forma prevista para probar la existencia de una clave en a dict.

d = {"key1": 10, "key2": 23}

if "key1" in d:
    print("this will execute")

if "nonexistent key" in d:
    print("this will not")

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

d = dict()

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

y si siempre quisiste asegurar un valor predeterminado para cualquier clave que puedas usar dict.setdefault()repetidamente o defaultdictdesde el collectionsmódulo, así:

from collections import defaultdict

d = defaultdict(int)

for i in range(100):
    d[i % 10] += 1

pero en general, la inpalabra 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 hashing del diccionario en lugar de hacer una búsqueda lineal, lo que haría las teclas de llamada.

Puede probar la presencia de una clave en un diccionario, utilizando 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 el valor por defecto (por ejemplo, si sus valores son listas, por ejemplo, y desea asegurarse de que haya una lista vacía a la que pueda agregar al insertar el primer valor para una clave). En casos como esos, puede encontrar el collections.defaultdict()tipo de interés.

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, en su lugar).

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?

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

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

Por lo tanto, el uso ino defaultdictse recomiendan contra get.

Recomendaría usar el setdefaultmétodo en su lugar. Parece que hará 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}

El diccionario en python tiene un método get ('clave', predeterminado). Por lo tanto, 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 SO:

Usar try vs if en python o

Comprobando la existencia de miembros en Python

Usando operador ternario:

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

Las formas en que puede obtener los resultados son:

• si your_dict.has_key (clave) Eliminado en Python 3
• si teclea tu_dict
• probar / excepto bloquear

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 ... más si ... más?
3. ¿Qué tan grande es el diccionario?

Lee mas: 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."

Solo Python 2: (y Python 2.7 inya es compatible )

puedes usar el método has_key ():

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

Solo un FYI que agrega a Chris. B (mejor respuesta):

d = defaultdict(int)

También funciona; la razón es que la llamada int()devuelve, 0que es lo que defaultdicthace detrás de escena (cuando se construye un diccionario), de ahí el nombre "Función de fábrica" ​​en la documentación.

Compruebe si ya existe una clave determinada en un diccionario

Para tener la idea de cómo hacerlo, primero inspeccionamos qué métodos podemos llamar en el diccionario. Aquí están los métodos:

d={'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

Python Dictionary clear()       Removes all Items
Python Dictionary copy()        Returns Shallow Copy of a Dictionary
Python Dictionary fromkeys()    Creates dictionary from given sequence
Python Dictionary get()         Returns Value of The Key
Python Dictionary items()       Returns view of dictionary (key, value) pair
Python Dictionary keys()        Returns View Object of All Keys
Python Dictionary pop()         Removes and returns element having given key
Python Dictionary popitem()     Returns & Removes Element From Dictionary
Python Dictionary setdefault()  Inserts Key With a Value if Key is not Present
Python Dictionary update()      Updates the Dictionary 
Python Dictionary values()      Returns view of all values in dictionary

El método brutal para verificar si la clave ya existe puede ser el get()método:

d.get("key")

Los otros dos métodos y sonidos interesantes parecen demasiado trabajo. Así que examinemos si es el método correcto para nosotros. Tenemos nuestro dict :items()keys()get()d

d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

La impresión muestra que la clave que no tenemos regresará None:

print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1

Nosotros podemos usar eso para obtener la información si la clave está presente o no. Pero considere esto si creamos un dict con un solo key:None:

d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

Liderar ese get()método no es confiable en caso de que algunos valores lo sean None. Esta historia debería tener un final más feliz. Si usamos el incomparador:

print('key' in d) #True
print('key2' in d) #False

Obtenemos los resultados correctos. Podemos examinar el código de bytes de Python:

import dis
dis.dis("'key' in d")
#   1           0 LOAD_CONST               0 ('key')
#               2 LOAD_NAME                0 (d)
#               4 COMPARE_OP               6 (in)
#               6 RETURN_VALUE

dis.dis("d.get('key2')")
#   1           0 LOAD_NAME                0 (d)
#               2 LOAD_METHOD              1 (get)
#               4 LOAD_CONST               0 ('key2')
#               6 CALL_METHOD              1
#               8 RETURN_VALUE

Esto muestra que el inoperador de comparación no solo es más confiable sino incluso más rápido que get().

El diccionario de Python tiene el método llamado __contains__. Este método devolverá True si el diccionario tiene la clave; de ​​lo contrario, devuelve 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.

Compartir una forma más de verificar si existe una clave utilizando operadores booleanos.

d = {'a': 1, 'b':2}
keys = 'abcd'

for k in keys:
    x = (k in d and 'blah') or 'boo'
    print(x) 

Esto vuelve

>>> blah
>>> blah
>>> boo
>>> boo

Explicación

En primer lugar usted debe saber que en Python, 0, None, o los objetos con longitud cero a evaluar False. Todo lo demás se evalúa a True. Las operaciones booleanas se evalúan de izquierda a derecha y devuelven el operando no verdadero o falso.

Veamos un ejemplo:

>>> 'Some string' or 1/0 
'Some string'
>>>

Como se 'Some string'evalúa como True, el resto del orno se evalúa y no se genera división por error cero.

Pero si cambiamos el orden 1/0se evalúa primero y se genera una excepción:

>>> 1/0 or 'Some string'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 

Podemos usar esto para el patrón para verificar si existe una clave.

(k in d and 'blah')

hace lo mismo que

if k in d:
    'blah'
else:
    False

Esto ya devuelve el resultado correcto si la clave existe, pero queremos que imprima 'boo' cuando no existe. Entonces, tomamos el resultado y orcon'boo'

>>> False or 'boo'
'boo'
>>> 'blah' or 'boo'
'blah'
>>> 

Puede usar el forbucle para iterar sobre el diccionario y obtener el nombre de la clave que desea encontrar en el diccionario, luego verifique si existe o no con la ifcondición:

dic = {'first' : 12, 'second' : 123}
for each in dic:
    if each == 'second': 
        print('the key exists and the corresponding value can be updated in the dictionary')