Verificar se uma dada chave já existe num dicionário
queria testar se existe uma chave num dicionário antes de actualizar o valor da chave. Eu escrevi o seguinte código:
if 'key1' in dict.keys():
print "blah"
else:
print "boo"
Acho que esta não é a melhor maneira de realizar esta tarefa. Há uma maneira melhor de testar uma chave no dicionário?
19 answers
in
é a forma pretendida de testar a existência de uma chave num dict
.
d = dict()
for i in xrange(100):
key = i % 10
if key in d:
d[key] += 1
else:
d[key] = 1
Se você queria um padrão, você pode sempre usar dict.get()
:
d = dict()
for i in xrange(100):
key = i % 10
d[key] = d.get(key, 0) + 1
... e se você quiser sempre garantir um valor padrão para qualquer chave você pode usar defaultdict
a partir do Módulo collections
, assim:
from collections import defaultdict
d = defaultdict(lambda: 0)
for i in xrange(100):
d[i % 10] += 1
... mas em geral, a palavra-chave é a melhor maneira de fazê-lo.
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:
...
No entanto, trata-se, na melhor das hipóteses, de uma melhoria cosmética. Porque é que achas que esta não é a melhor maneira?
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:
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:
- O dicionário 'normalmente tem a chave' ou'normalmente não tem a chave'.
- 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