python - recorrer - ¿Por qué dict.get(clave) en lugar de dict[clave]?

propiedades diccionarios python

Question

Hoy, encontré el método dict que, dado una clave en el diccionario, devuelve el valor asociado.

¿Para qué sirve esta función? Si quisiera encontrar un valor asociado con una clave en un diccionario, solo puedo hacer dict[key] , y devuelve lo mismo:

dictionary = {"Name": "Harry", "Age": 17}
dictionary["Name"]
dictionary.get("Name")

Answer 1

¿Para qué sirve esta función?

Un uso particular es contar con diccionario. Supongamos que desea contar un número de apariciones de cada elemento en una lista dada. La forma común de hacerlo es hacer un diccionario donde las claves son elementos y los valores son el número de ocurrencias.

fruits = [''apple'', ''banana'', ''peach'', ''apple'', ''pear'']
d = {}
for fruit in fruits:
    if fruit not in d:
        d[fruit] = 0
    d[fruit] += 1

Usando el método .get () puede hacer que este código sea más compacto y claro:

for fruit in fruits:
      d[fruit] = d.get(fruit, 0) + 1

Answer 2

¿Por qué dict.get (clave) en lugar de dict [clave]?

0. Resumen

Comparando con dict[key] , dict.get proporciona un valor de reserva al buscar una clave.

1. definición

get (clave [, predeterminado]) 4. Tipos incorporados: documentación de Python 3.6.4rc1

Devuelve el valor para clave si la clave está en el diccionario, de lo contrario, el valor predeterminado. Si no se proporciona el valor predeterminado, el valor predeterminado es Ninguno, por lo que este método nunca genera un 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. Problema que resuelve.

Si no tiene un default value , debe escribir códigos complicados para manejar dicha excepción.

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 una solución conveniente, dict.get introduce un valor predeterminado opcional que evita los códigos anteriores.

3. Conclusión

dict.get tiene una opción de valor predeterminado adicional para lidiar con la excepción si la clave está ausente en el diccionario

Answer 3

¿Qué es el método dict.get() ?

Como ya se mencionó, el método get contiene un parámetro adicional que indica el valor faltante. De la documentación

get(key[, default])

Devuelve el valor para clave si la clave está en el diccionario, de lo contrario, el valor predeterminado. Si no se proporciona el valor predeterminado, el valor predeterminado es Ninguno, por lo que este método nunca genera un KeyError .

Un ejemplo puede 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

¿Hay mejoras de velocidad en alguna parte?

Como se mencionó here ,

Parece que los tres enfoques ahora muestran un rendimiento similar (dentro de aproximadamente el 10% entre sí), más o menos independientes de las propiedades de la lista de palabras.

La get anterior fue considerablemente más lenta. Sin embargo, ahora la velocidad es casi comparable junto con la ventaja adicional de devolver el valor predeterminado. Pero para eliminar todas nuestras consultas, podemos realizar pruebas en una lista bastante grande (tenga en cuenta que la prueba incluye buscar todas las claves válidas solamente)

def getway(d):
    for i in range(100):
        s = d.get(i)

def lookup(d):
    for i in range(100):
        s = d[i]

Ahora sincronizando estas dos funciones 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, la búsqueda es más rápida que la obtención, ya que no hay una función de búsqueda. Esto se puede ver a través de 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  

¿Dónde será útil?

Será útil siempre que desee proporcionar un valor predeterminado cuando busque un diccionario. Esto reduce

 if key in dic:
      val = key[dic]
 else:
      val = def_val

A una sola línea, val = dic.get(key,def_val)

¿Dónde NO será útil?

Cada vez que desee devolver un KeyError indicando que la clave en particular no está disponible. Devolver un valor predeterminado también conlleva el riesgo de que un valor predeterminado particular también pueda ser una clave.

¿Es posible tener get función similar en dict[''key''] ?

¡Sí! Necesitamos implementar el __missing__ en una subclase de dict.

Un programa de ejemplo puede ser

class MyDict(dict):
    def __missing__(self, key):
        return None

Una pequeña demostración puede ser

>>> my_d = MyDict({1:2,2:3})
>>> my_d[1]
2
>>> my_d[3]
>>> repr(my_d[3])
''None''

Answer 4

Basado en el uso debe utilizar este método de get .

Ejemplo 1

In [14]: user_dict = {''type'': False}

In [15]: user_dict.get(''type'', '''')

Out[15]: False

In [16]: user_dict.get(''type'') or ''''

Out[16]: ''''

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

Answer 5

Daré un ejemplo práctico al raspar datos web usando python, muchas de las veces obtendrá claves sin valores, en esos casos obtendrá errores si usa el diccionario [''key''], mientras que dictionary.get (''key '','' return_otherwise '') no tiene problemas.

De forma similar, usaría '''' .join (lista) en lugar de la lista [0] si intenta capturar un solo valor de una lista.

Espero eso ayude.

[Editar] Aquí hay un ejemplo práctico:

Supongamos que está llamando a una API, que devuelve un archivo JOSN que necesita analizar. El primer JSON se parece a lo siguiente:

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

El segundo JOSN es así:

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

Tenga en cuenta que al segundo JSON le falta la clave "submitdate_ts", que es bastante normal en cualquier estructura de datos.

Entonces, cuando intenta acceder al valor de esa clave en un bucle, puede llamarlo con lo siguiente:

for item in API_call:
    submitdate_ts = item["bids"]["submitdate_ts"]

Podría, pero le dará un error de rastreo para la segunda línea JSON, porque la clave simplemente no existe.

La forma apropiada de codificar esto, podría ser la siguiente:

for item in API_call:
    submitdate_ts = item.get("bids", {''x'': None}).get("submitdate_ts")

{''x'': Ninguno} está ahí para evitar que el segundo nivel reciba un error. Por supuesto, puede incorporar más tolerancia a fallas en el código si está haciendo raspado. Como primero especificando una condición if

Answer 6

El propósito es que puede dar un valor predeterminado si no se encuentra la clave, lo cual es muy útil

dictionary.get("Name",''harry'')

Answer 7

Le permite proporcionar un valor predeterminado si falta la clave:

dictionary.get("bogus", default_value)

devuelve default_value (cualquiera que sea su elección), mientras que

dictionary["bogus"]

elevaría un KeyError .

Si se omite, el valor default_value es None , por lo que

dictionary.get("bogus")  # <-- No default specified -- defaults to None

devuelve None al igual que

dictionary.get("bogus", None)

haría.

Answer 8

get toma un segundo valor opcional. Si la clave especificada no existe en su diccionario, se devolverá este valor.

dictionary = {"Name": "Harry", "Age": 17}
dictionary.get(''Year'', ''No available data'')
>> ''No available data''

Si no da el segundo parámetro, se devolverá None .

Si utiliza la indexación como en el dictionary[''Year''] , las claves no existentes generarán KeyError .

Answer 9

• dict.get no devolverá nada por defecto si la clave no existe, pero si coloca un segundo argumento, devolverá si la clave no existe.

• OTOH dict[key] generará KeyError si la clave no existe.

Aquí hay un ejemplo (leer comentarios):

>>> d={''a'':[1,2,3],''b'':[4,5,6]} # Create a dictionary
>>> d[''c''] # Hoops, error key does not exist
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    d[''c'']
KeyError: ''c''
>>> d.get(''c'') # no error because of `get`, so nothing returned
>>> print(d.get(''c'')) # i print it, oh `None` is the output
None
>>> d.get(''c'',100) # Okay now i set second argument''s value to `100`, hoopa output is `100`
100
>>> d[''a''] # Works, key exist
[1, 2, 3]
>>> d.get(''a'') # work too, key exist
[1, 2, 3]