这样做的目的是，如果没有找到键，您可以给出一个默认值，这非常有用

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

它允许你在缺少键时提供一个默认值:

dictionary.get("bogus", default_value)

返回default_value(不管你选择它是什么)，而

dictionary["bogus"]

会引发一个KeyError。

如果省略，default_value为None，这样

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

返回None

dictionary.get("bogus", None)

会。

这样做的目的是，如果没有找到键，您可以给出一个默认值，这非常有用

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

为什么dict.get(key)而不是dict[key]?

0. 总结

与dict[键]相比，dict。Get在查找键时提供一个回退值。

1. 定义

Get (key[， default])内置类型- Python 3.6.4rc1文档

如果key在字典中，则返回key的值，否则为default。如果没有给出default，则默认为None，因此该方法永远不会引发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. 问题解决了。

如果没有默认值，则必须编写繁琐的代码来处理此类异常。

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'

作为一个方便的解决方案，dict。Get引入了一个可选的默认值，避免了上述杂乱的代码。

3.结论

字典Get有一个额外的默认值选项，用于在字典中缺少key时处理异常

另一个我没有看到提到的用例是作为sort, max和min等函数的key参数。get方法允许根据它们的值返回键。

>>> ages = {"Harry": 17, "Lucy": 16, "Charlie": 18}
>>> print(sorted(ages, key=ages.get))
['Lucy', 'Harry', 'Charlie']
>>> print(max(ages, key=ages.get))
Charlie
>>> print(min(ages, key=ages.get))
Lucy

感谢对不同问题的回答提供了这个用例!

什么是dict.get()方法?

如前所述，get方法包含一个附加参数，用于指示缺少的值。来自文档

get(键(默认)) 如果key在字典中，则返回key的值，否则为default。如果没有给出default，则默认为None，因此该方法永远不会引发KeyError。

一个例子是

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

哪里有提高速度的地方吗?

正如这里提到的，

现在看来，这三种方法表现出相似的性能(彼此相差约10%)，或多或少与单词列表的属性无关。

早期的get相当慢，但是现在的速度几乎是相当的，以及返回默认值的额外优势。但是为了清除所有的查询，我们可以在一个相当大的列表上进行测试(注意，测试只包括查找所有有效的键)

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

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

现在使用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

正如我们所看到的，查找比get快，因为没有函数查找。这可以通过这个看出

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

它在哪里有用?

当您在查找字典时希望提供一个默认值时，它将非常有用。这减少了

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

val = dic.get(key,def_val)

在哪里它是无用的?

当您希望返回一个KeyError，说明特定的键不可用时。返回默认值也有风险，即特定的默认值也可能是键!

是否可能在dict['key']中有get like特征?

是的!我们需要在dict子类中实现__missing__。

示例程序可以是

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

一个小小的示范就可以了

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