Verificar se uma dada chave já existe num dicionário

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

Isso será muito mais rápido porque ele usa a hashing do dicionário em vez de fazer uma busca linear, o que chaves chamadas faria.

Pode testar a presença de uma chave num dicionário, usando a em palavra-chave:

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 mutação, o que é padrão-inicializar o valor (por exemplo, se os valores são listas, por exemplo, e você quer garantir que não é uma lista vazia para que você pode acrescentar ao inserir o primeiro valor para uma chave). Em casos como esses, você pode encontrar o collections.defaultdict() tipo de interesse.

Em código mais antigo, você também pode encontrar alguns usos de has_key(), um método depreciado para verificar a existência de chaves em dicionários (basta usar key_name in dict_name, em vez disso).

Podes encurtar isto:

if 'key1' in dict:
    ...

Eu recomendaria usar o método setdefault em vez disso. Parece que vai fazer tudo o que quiseres.

>>> 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 informações adicionais sobre a execução rápida dos métodos propostos da resposta aceite (loops de 10m):

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

Portanto, recomenda-se a utilização de in ou defaultdict contra get.

O dicionário em python tem um método get ('key', por omissão). Então você pode apenas definir um valor padrão no caso de não haver nenhuma chave.

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

Que tal usar a EAFP (mais fácil de pedir perdão do que Permissão):

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

Ver outros posts:

Usar o try vs if em python ou

A verificar a existência do Membro em Python

Para verificar pode utilizar has_key() Método

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

Se quiser um valor, pode utilizar get() o método

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

Se quiser uma tupla, uma lista ou um dicionário ou qualquer texto como valor por omissão como valor de retorno, então use get() Método

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

Usando o operador ternário:

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

Só para tua informação, a acrescentar ao Chris. B (Melhor Resposta):

d = defaultdict(int)

Também funciona; a razão é que chamar int() devolve 0 que é o que defaultdict faz nos bastidores (ao construir um dicionário), daí o nome "Função de fábrica" na documentação.

As formas como você pode obter os resultados são:

Se é o teu Decreto.has_key (chave) removido no Python 3
• se a chave no seu _dito
• tentar / excepto bloco

O que é melhor depende de 3 Coisas:

1. O dicionário 'normalmente tem a chave' ou'normalmente não tem a chave'.
2. pretende utilizar condições como if...mais...elseif...mais?
Qual é o tamanho? dicionário?

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

Utilização de tentar / bloquear 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."

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

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

Ou o método dict.get para definir um valor por omissão se não for encontrado:

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

Não imprimirá o boo pelos valores do dict, mas cumpre o objectivo imprimindo o valor do key1 para confirmar a sua existência.

O dicionário Python tem o método chamado __contains__. Este método irá retornar verdadeiro se o dicionário tem a chave de outra forma retorna falso.

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

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

A mais fácil é saber qual a chave (Nome da chave) que deve procurar:

# 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

Ou pode fazer simplesmente como:

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

Eu uso o tentar / excepto ; Se for disparada uma excepção, a chave não está presente no dicionário. exemplo:

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

Porque não usar apenas o método has_key ().

a = {}
a.has_key('b') => #False

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