Porquê dict.obter (chave) em vez de dict[chave]?
hoje, deparei-me com o método dict
que, dada uma chave no dicionário, devolve o valor associado.
para que propósito esta função é útil? Se eu quisesse encontrar um valor associado a uma chave em um dicionário, eu posso fazer dict[key]
, e ele retorna a mesma coisa:
dictionary = {"Name": "Harry", "Age": 17}
dictionary["Name"]
dictionary.get("Name")
8 answers
Permite-lhe indicar um valor por omissão se a chave faltar:
dictionary.get("bogus", default_value)
Devolve default_value
(Seja qual for a sua escolha), enquanto
dictionary["bogus"]
Aumentaria um KeyError
.
Se omitido, default_value
é None
, tal que
dictionary.get("bogus") # <-- No default specified -- defaults to None
Devolve None
tal como
dictionary.get("bogus", None)
Faria.
Qual é o método
dict.get()
?
Como já mencionado, o método get
contém um parâmetro adicional que indica o valor em falta. da documentação
get(key[, default])
Devolve o valor da chave se a chave estiver no dicionário, caso contrário, por omissão. Se o valor por omissão não for indicado, é por omissão nulo, de modo que este método nunca levanta um
KeyError
.
Um exemplo pode ser
>>> d = {1:2,2:3}
>>> d[1]
2
>>> d.get(1)
2
>>> d.get(3)
>>> repr(d.get(3))
'None'
>>> d.get(3,1)
1
Há melhorias de Velocidade em algum lugar?
Como mencionado aqui,
Parece que todas as três abordagens apresentam agora desempenho semelhante (dentro de cerca de 10% um do outro), mais ou menos independente das propriedades da lista de palavras.
Anteriormente get
era consideravelmente mais lento, no entanto agora a velocidade é quase comparável, juntamente com a vantagem adicional de retornar o valor padrão. Mas para esclarecer todas as nossas dúvidas, podemos testar numa lista grande (lembre-se que o teste inclui procurar todas as chaves válidas apenas)
def getway(d):
for i in range(100):
s = d.get(i)
def lookup(d):
for i in range(100):
s = d[i]
Agora cronometra estas duas funções usando timeit
>>> import timeit
>>> print(timeit.timeit("getway({i:i for i in range(100)})","from __main__ import getway"))
20.2124660015
>>> print(timeit.timeit("lookup({i:i for i in range(100)})","from __main__ import lookup"))
16.16223979
Como podemos ver, a pesquisa é mais rápida do que a busca, pois não há pesquisa de funções. Isto pode ser visto através dis
>>> def lookup(d,val):
... return d[val]
...
>>> def getway(d,val):
... return d.get(val)
...
>>> dis.dis(getway)
2 0 LOAD_FAST 0 (d)
3 LOAD_ATTR 0 (get)
6 LOAD_FAST 1 (val)
9 CALL_FUNCTION 1
12 RETURN_VALUE
>>> dis.dis(lookup)
2 0 LOAD_FAST 0 (d)
3 LOAD_FAST 1 (val)
6 BINARY_SUBSCR
7 RETURN_VALUE
Onde será útil?
Será útil sempre que quiser fornecer um valor por omissão sempre que estiver à procura de um dicionário. Presente reduz
if key in dic:
val = key[dic]
else:
val = def_val
Para uma única linha, val = dic.get(key,def_val)
Onde não será útil?
Sempre que quiser devolver um KeyError
afirmando que a chave em particular não está disponível. Devolver um valor padrão também acarreta o risco de que um determinado valor padrão possa ser uma chave também!
Sim! Temos de implementar oÉ possível ter uma característica similar em
dict['key']
?
__missing__
num dict subclasse.
UM programa de amostragem pode ser
class MyDict(dict):
def __missing__(self, key):
return None
Uma pequena demonstração pode ser
>>> my_d = MyDict({1:2,2:3})
>>> my_d[1]
2
>>> my_d[3]
>>> repr(my_d[3])
'None'
get
é preciso um segundo valor opcional. Se a chave especificada não existir no seu dicionário, então este valor será devolvido.
dictionary = {"Name": "Harry", "Age": 17}
dictionary.get('Year', 'No available data')
>> 'No available data'
Se não indicar o segundo parâmetro, None
será devolvido.
Se usar a indexação como em dictionary['Year']
, as chaves inexistentes irão aumentar KeyError
.
Vou dar um exemplo prático ao raspar dados web usando python, muitas das vezes você vai obter chaves sem valores, nesses casos você vai obter erros se você usar dicionário ['chave'], enquanto dicionário.o get ("chave", "retorno_outro sentido") não tem problemas.
Da mesma forma, eu usaria ".juntar (lista) em vez de listar[0] se tentar capturar um único valor de uma lista.
Espero que ajude.[Editar] aqui está um exemplo prático:
Estás a chamar uma API., que devolve um ficheiro JOSN que precisa de analisar. O primeiro JSON parece ser o seguinte:{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","submitdate_ts":1318794805,"users_id":"2674360","project_id":"1250499"}}
O segundo JOSN é assim:
{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","users_id":"2674360","project_id":"1250499"}}
Note que o segundo JSON está faltando a chave "submitdate_ts", que é bastante normal em qualquer estrutura de dados.
Então, quando você tentar acessar o valor dessa chave em um loop, você pode chamá-lo com o seguinte:for item in API_call:
submitdate_ts = item["bids"]["submitdate_ts"]
Você poderia, mas isso lhe dará um erro de rastreamento para a segunda linha JSON, porque a chave simplesmente não existir.
A forma adequada de codificar isto pode ser a seguinte:
for item in API_call:
submitdate_ts = item.get("bids", {'x': None}).get("submitdate_ts")
{'x': nenhum} existe para evitar que o segundo nível obtenha um erro. Claro que você pode construir mais tolerância de falha no código se você estiver fazendo raspagem. Como primeiro especificar uma condição if
O objectivo é que você pode dar um valor por omissão se a chave não for encontrada, o que é muito útil
dictionary.get("Name",'harry')
Para que propósito esta função é útil?
Uma utilização particular é contar com o dicionário. Vamos supor que você quer contar um número de ocorrências de cada elemento em uma determinada lista. A maneira comum de fazê-lo é fazer um dicionário onde chaves são elementos e valores são o número de ocorrências.
fruits = ['apple', 'banana', 'peach', 'apple', 'pear']
d = {}
for fruit in fruits:
if fruit not in d:
d[fruit] = 0
d[fruit] += 1
Usando o .método get () você pode tornar este código mais compacto e claro:
for fruit in fruits:
d[fruit] = d.get(fruit, 0) + 1
Baseado no uso deve usar este método get
.
Examplo1
In [14]: user_dict = {'type': False}
In [15]: user_dict.get('type', '')
Out[15]: False
In [16]: user_dict.get('type') or ''
Out[16]: ''
Exemplo 2
In [17]: user_dict = {'type': "lead"}
In [18]: user_dict.get('type') or ''
Out[18]: 'lead'
In [19]: user_dict.get('type', '')
Out[19]: 'lead'
Porquê dict.obter (chave) em vez de dict[chave]?
0. Resumo
Comparando com dict[key]
, dict.get
fornece um valor de recurso ao procurar uma chave.
1. Definição
Get (chave[, por omissão]) 4. Tipos incorporados-documentação em Python 3.6. 4rc1
Devolve o valor da chave se a chave estiver no dicionário, caso contrário, por omissão. Se o valor por omissão não for indicado, o valor por omissão é nulo, de modo que este método nunca levante um KeyError.
d = {"Name": "Harry", "Age": 17}
In [4]: d['gender']
KeyError: 'gender'
In [5]: d.get('gender', 'Not specified, please add it')
Out[5]: 'Not specified, please add it'
2. O problema resolve-se.
Se sem default value
, tens de escrever códigos complicados para lidar com tal excepção.
def get_harry_info(key):
try:
return "{}".format(d[key])
except KeyError:
return 'Not specified, please add it'
In [9]: get_harry_info('Name')
Out[9]: 'Harry'
In [10]: get_harry_info('Gender')
Out[10]: 'Not specified, please add it'
Como uma solução conveniente, dict.get
introduz um valor opcional por defeito, evitando acima de códigos involuntários.
3. Conclusão
dict.get
tem uma opção de valor por omissão adicional para lidar com a excepção se a chave estiver ausente do dicionário