Eu queria testar se existe uma chave em um dicionário antes de atualizar o valor da chave. Eu escrevi o seguinte código:

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

Eu acho que essa não é a melhor maneira de realizar essa tarefa. Existe uma maneira melhor de testar uma chave no dicionário?

iné a maneira pretendida de testar a existência de uma chave em a dict.

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

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

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

Se você queria um padrão, sempre pode usar dict.get():

d = dict()

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

e se você sempre quis garantir um valor padrão para qualquer chave, pode usar dict.setdefault()repetidamente ou defaultdictno collectionsmódulo, da seguinte maneira:

from collections import defaultdict

d = defaultdict(int)

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

mas, em geral, a inpalavra-chave é a melhor maneira de fazer isso.

Você não precisa chamar as teclas:

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

Isso será muito mais rápido , pois usa o hash do dicionário em vez de fazer uma pesquisa linear, o que as teclas de chamada fariam.

Você pode testar a presença de uma chave em um dicionário usando a palavra-chave in :

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

Um uso comum para verificar a existência de uma chave em um dicionário antes de alterá-la é inicializar o valor por padrão (por exemplo, se seus valores são listas, por exemplo, e você deseja garantir que exista uma lista vazia à qual possa anexar ao inserir o primeiro valor para uma chave). Em casos como esses, você pode achar que o collections.defaultdict()tipo é do seu interesse.

No código antigo, você também pode encontrar alguns usos de has_key(), um método obsoleto para verificar a existência de chaves nos dicionários (basta usar key_name in dict_name).

Você pode encurtar isso:

if 'key1' in dict:
    ...

No entanto, isso é, na melhor das hipóteses, uma melhoria cosmética. Por que você acredita que esse não é o melhor caminho?

Para informações adicionais sobre a velocidade de execução dos métodos propostos da resposta aceita (10m loops):

• 'key' in mydict tempo decorrido 1,07 seg
• mydict.get('key') tempo decorrido 1,84 seg
• mydefaultdict['key'] tempo decorrido 1,07 seg

Portanto, é recomendável usar inou defaultdictcontra get.

Eu recomendaria usar o setdefaultmétodo. Parece que fará tudo o que você quiser.

>>> 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}

O dicionário em python possui um método get ('key', padrão). Portanto, você pode apenas definir um valor padrão, caso não haja chave.

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

Que tal usar o EAFP (é mais fácil pedir perdão do que permissão):

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

Veja outras postagens do SO:

Usando try vs if em python ou

Verificando a existência de membros em Python

Usando operador ternário:

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

As maneiras pelas quais você pode obter os resultados são:

• if your_dict.has_key (key) Removido no Python 3
• se digite seu_dict
• tentar / exceto bloco

O que é melhor depende de três coisas:

1. O dicionário 'normalmente possui a chave' ou 'normalmente não possui a chave'.
2. Você pretende usar condições como se ... else ... elseif ... else?
3. Qual é o tamanho do dicionário?

Leia mais: http://paltman.com/try-except-performance-in-python-a-simple-test/

Uso de try / block em vez de 'in' ou '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."

Somente Python 2: (e o python 2.7 injá suporta )

você pode usar o método has_key ():

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

Apenas um FYI adicionando a Chris. B (melhor resposta):

d = defaultdict(int)

Funciona também; a razão é que a chamada int()retorna, o 0que defaultdictocorre nos bastidores (ao construir um dicionário), daí o nome "Factory Function" na documentação.

Verifique se uma chave já existe em um dicionário

Para ter uma idéia de como fazer isso, primeiro inspecionamos quais métodos podemos chamar no dicionário. Aqui estão os 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

O método brutal para verificar se a chave já existe pode ser o get()método:

d.get("key")

Os outros dois métodos interessantesitems() e keys()parecem muito trabalho. Então, vamos examinar se get()é o método certo para nós. Temos o nosso ditado d:

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

A impressão mostra a chave que não temos retornará None:

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

Nós podem usar isso para obter a informação se a chave está presente ou não. Mas considere isso se criarmos um ditado com um único key:None:

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

Liderar esse get()método não é confiável, caso alguns valores possam ser None. Esta história deve ter um final mais feliz. Se usarmos o incomparador:

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

Nós obtemos os resultados corretos. Podemos examinar o código de bytes do 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

Isso mostra que o inoperador de comparação não é apenas mais confiável, mas ainda mais rápido que get().

Dicionário Python tem o método chamado __contains__. Este método retornará True se o dicionário tiver a chave else retorna 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.

Compartilhando mais uma maneira de verificar se existe uma chave usando operadores booleanos.

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

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

Isso retorna

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

Explicação

Primeiro você deve saber que em Python, 0, None, ou objetos com comprimento zero avaliar a False. Tudo o resto é avaliado True. As operações booleanas são avaliadas da esquerda para a direita e retornam o operando não True ou False.

Vamos ver um exemplo:

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

Como 'Some string'avalia para True, o restante do ornão é avaliado e não há divisão por erro zero gerado.

Mas se mudarmos, a ordem 1/0é avaliada primeiro e gera uma exceção:

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

Podemos usar isso como padrão para verificar se existe uma chave.

(k in d and 'blah')

faz o mesmo que

if k in d:
    'blah'
else:
    False

Isso já retorna o resultado correto se a chave existir, mas queremos que ela imprima 'vaia' quando não existir. Então, pegamos o resultado e orele com'boo'

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

Você pode usar forloop para iterar sobre o dicionário e obter o nome da chave que deseja encontrar no dicionário; depois disso, verifique se existe ou não usando a ifcondição:

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')