python split - Verificar se uma determinada chave já existe em um dicionário




dicionario transformar (17)

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?


Answers

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

Não imprime boo para os valores no dict, mas realiza o objetivo imprimindo o valor de key1 para confirmar sua existência.


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 padrã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

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

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

Eu recomendaria usar o método setdefault . Parece que vai fazer tudo o que 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}

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

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

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


Eu uso o try / exceto ; Se uma exceção for lançada, a chave não estará presente no dicionário. exemplo:

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

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

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

d = defaultdict(int)

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


Você não precisa ligar para as chaves:

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

Isso será muito faster , pois usa o hashing do dicionário, em vez de fazer uma pesquisa linear, que as teclas de chamada fazem.


Usando o operador ternário:

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

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

Qual é o melhor depende de 3 coisas:

  1. O dicionário "normalmente tem a chave" ou "normalmente não tem a chave".
  2. Você pretende usar condições como if ... else ... elseif ... else?
  3. Quão grande é o dicionário?

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

Uso de try / block ao invés 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 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 por padrão o valor (por exemplo, se seus valores são listas, por exemplo, e você deseja garantir que haja uma lista vazia à qual você pode acrescentar ao inserir o primeiro valor de uma chave). Em casos como esses, você pode achar que o tipo collections.defaultdict() é de interesse.

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


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

  • 'key' in mydict tempo decorrido 1.07 seg
  • mydict.get('key') tempo decorrido 1.84 sec
  • mydefaultdict['key'] tempo decorrido 1.07 seg

Portanto, usar in ou defaultdict é recomendado contra get .


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 este não é o melhor caminho?


Para verificar, você pode usar o método has_key()

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

Se você quer um valor, então você pode usar o método get()

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

Se você quiser uma tupla ou lista ou dicionário ou qualquer string como um valor padrão como valor de retorno, use o método get()

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

* args e ** kwargs são recursos mágicos especiais do Python. Pense em uma função que poderia ter um número desconhecido de argumentos. Por exemplo, por qualquer motivo, você quer ter uma função que some um número desconhecido de números (e você não quer usar a função soma incorporada). Então você escreve esta função:

def sumFunction(*args):
  result = 0
  for x in args:
    result += x
  return result

e usá-lo como: sumFunction (3,4,6,3,6,8,9).

** kwargs tem uma função diferente. Com ** kwargs você pode dar argumentos arbitrários para uma função e você pode acessá-los como um dictonary.

def someFunction(**kwargs):
  if 'text' in kwargs:
    print kwargs['text']

Chamar someFunction (text = "foo") será impresso foo.





python dictionary