如果字典键不可用，则返回默认值

Question

我需要一种方法来获取字典值（如果其键存在），或者简单地返回

None

（如果不存在）。

但是，如果您搜索不存在的键，Python 会引发

KeyError

异常。我知道我可以检查密钥，但我正在寻找更明确的内容。如果密钥不存在，有没有办法只返回

None

？

---

_{另请参阅： 为什么 dict.get(key) 而不是 dict[key]？}

Answer 1

您可以使用

dict.get()

value = d.get(key)

如果

None

，将返回

key is not in d

。您还可以提供将返回的不同默认值，而不是

None

:

value = d.get(key, "empty")

Answer 2

不再疑惑。它内置于语言中。

 >>> 帮助（字典）

    有关模块内置中的类字典的帮助：

    类字典（对象）
     | dict() -> 新的空字典
     | dict(mapping) -> 从映射对象初始化的新字典
     | （键，值）对
    ...
     |
     |得到（...）
     | D.get(k[,d]) -> D[k] 如果 k 在 D 中，否则 d。 d 默认为无。
     |
    ...

Answer 3

您应该使用

get()

类中的

dict

方法

d = {}
r = d.get('missing_key', None)

这将导致

r == None

。如果在字典中找不到该键，则 get 函数返回第二个参数。

Answer 4

使用

dict.get

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

Answer 5

如果您想要更透明的解决方案，您可以子类化

dict

来获得此行为：

class NoneDict(dict):
    def __getitem__(self, key):
        return dict.get(self, key)

>>> foo = NoneDict([(1,"asdf"), (2,"qwerty")])
>>> foo[1]
'asdf'
>>> foo[2]
'qwerty'
>>> foo[3] is None
True

Answer 6

我通常在这种情况下使用 defaultdict。您提供一个不带参数的工厂方法，并在看到新键时创建一个值。当您想要返回新键上的空列表之类的内容时，它更有用（参见示例）。

from collections import defaultdict
d = defaultdict(lambda: None)
print d['new_key']  # prints 'None'

Answer 7

单行解决方案是：

item['key'] if 'key' in item else None

当尝试将字典值添加到新列表并想要提供默认值时，这非常有用：

例如。

row = [item['key'] if 'key' in item else 'default_value']

Answer 8

正如其他人上面所说，你可以使用 get()。

但是要检查密钥，您也可以这样做：

d = {}
if 'keyname' in d:

    # d['keyname'] exists
    pass

else:

    # d['keyname'] does not exist
    pass

Answer 9

您可以使用

dict

对象的

get()

方法，正如其他人已经建议的那样。或者，根据您正在做什么，您可能可以使用像这样的

try/except

套件：

try:
   <to do something with d[key]>
except KeyError:
   <deal with it not being there>

这被认为是一种非常“Pythonic”的处理案例的方法。

Answer 10

对于那些使用

dict.get

技术进行嵌套字典的人，您可以将默认返回值设置为除最外层之外的空字典，而不是显式检查字典的每个级别或扩展

dict

类。这是一个例子：

my_dict = {'level_1': {
             'level_2': {
                  'level_3': 'more_data'
                  }
              }
           }
result = my_dict.get('level_1', {}).get('level_2', {}).get('level_3')
# result -> 'more_data'
none_result = my_dict.get('level_1', {}).get('what_level', {}).get('level_3')
# none_result -> None

警告：请注意，此技术仅在预期键的值是字典时才有效。如果键

what_level

确实存在于字典中，但其值是字符串或整数等，那么它会引发

AttributeError

。

Answer 11

我对 python2 与 python3 的可能性感到惊讶。我将根据我最终为 python3 所做的事情来回答它。我的目标很简单：检查字典格式的 json 响应是否给出错误。我的字典称为“令牌”，我正在寻找的密钥是“错误”。我正在寻找关键的“错误”，如果不存在，则将其设置为“无”值，然后检查该值是否为“无”，如果是，则继续执行我的代码。如果我确实有关键的“错误”，则 else 语句将处理。

if ((token.get('error', None)) is None):
    do something

Answer 12

您可以使用 try- except 块

try:
    value = dict['keyname']

except IndexError:
    value = None

Answer 13

1. d1={"一":1,"二":2,"三":3}

2. d1.get("四")

如果您运行此代码，将不会出现“Keyerror”，这意味着您可以使用“dict.get()”来避免错误并执行您的代码

Answer 14

如果您有相当于缓存的更复杂的需求，此类可能会派上用场：

class Cache(dict):
    """ Provide a dictionary based cache

        Pass a function to the constructor that accepts a key and returns
        a value.  This function will be called exactly once for any key
        required of the cache.
    """

    def __init__(self, fn):
        super()
        self._fn = fn

    def __getitem__(self, key):
        try:
            return super().__getitem__(key)
        except KeyError:
            value = self[key] = self._fn(key)
            return value

构造函数接受一个使用键调用的函数，并应返回字典的值。然后存储该值并下次从字典中检索该值。像这样使用它...

def get_from_database(name):
    # Do expensive thing to retrieve the value from somewhere
    return value

answer = Cache(get_from_database)
x = answer(42)   # Gets the value from the database
x = answer(42)   # Gets the value directly from the dictionary

Answer 15

如果你可以用

False

做到这一点，那么，还有 hasattr 内置功能：

e=dict()
hasattr(e, 'message'):
>>> False