是否有更可读的方法来检查是否存在嵌入字典的键而无需独立检查每个级别？

可以说我需要在埋藏的对象中获取此值（示例取自Wikidata）：

x = s['mainsnak']['datavalue']['value']['numeric-id']

为了确保不会以运行时错误结束，有必要检查每个级别，如下所示：

if 'mainsnak' in s and 'datavalue' in s['mainsnak'] and 'value' in s['mainsnak']['datavalue'] and 'nurmeric-id' in s['mainsnak']['datavalue']['value']:
    x = s['mainsnak']['datavalue']['value']['numeric-id']

我可以想到的另一种解决方法是将其包装到一个try catch结构中，对于这样一个简单的任务，我也觉得很尴尬。

我正在寻找类似的东西：

x = exists(s['mainsnak']['datavalue']['value']['numeric-id'])

True如果所有级别都存在，则返回。

简而言之，使用Python，您必须相信请求宽恕比允许许可容易

try:
    x = s['mainsnak']['datavalue']['value']['numeric-id']
except KeyError:
    pass

答案

这是我处理嵌套dict键的方法：

def keys_exists(element, *keys):
    '''
    Check if *keys (nested) exists in `element` (dict).
    '''
    if not isinstance(element, dict):
        raise AttributeError('keys_exists() expects dict as first argument.')
    if len(keys) == 0:
        raise AttributeError('keys_exists() expects at least two arguments, one given.')

    _element = element
    for key in keys:
        try:
            _element = _element[key]
        except KeyError:
            return False
    return True

例：

data = {
    "spam": {
        "egg": {
            "bacon": "Well..",
            "sausages": "Spam egg sausages and spam",
            "spam": "does not have much spam in it"
        }
    }
}

print 'spam (exists): {}'.format(keys_exists(data, "spam"))
print 'spam > bacon (do not exists): {}'.format(keys_exists(data, "spam", "bacon"))
print 'spam > egg (exists): {}'.format(keys_exists(data, "spam", "egg"))
print 'spam > egg > bacon (exists): {}'.format(keys_exists(data, "spam", "egg", "bacon"))

输出：

spam (exists): True
spam > bacon (do not exists): False
spam > egg (exists): True
spam > egg > bacon (exists): True

它以给element定的顺序循环进行给定的测试。

与variable.get('key', {})我发现的所有方法相比，我都更喜欢此方法，因为它遵循EAFP。

功能除外，例如：keys_exists(dict_element_to_test, 'key_level_0', 'key_level_1', 'key_level_n', ..)。至少需要两个参数，元素和一个键，但是您可以添加所需的键数。

如果您需要使用某种地图，则可以执行以下操作：

expected_keys = ['spam', 'egg', 'bacon']
keys_exists(data, *expected_keys)

您可以使用.get默认值：

s.get('mainsnak', {}).get('datavalue', {}).get('value', {}).get('numeric-id')

但这几乎可以肯定不如使用try / except清楚。

尝试/例外似乎是最Python化的方法。
以下递归函数应该起作用（如果在dict中未找到其中一个键，则返回None）：

def exists(obj, chain):
    _key = chain.pop(0)
    if _key in obj:
        return exists(obj[_key], chain) if chain else obj[_key]

myDict ={
    'mainsnak': {
        'datavalue': {
            'value': {
                'numeric-id': 1
            }
        }
    }
}

result = exists(myDict, ['mainsnak', 'datavalue', 'value', 'numeric-id'])
print(result)
>>> 1

您可以pydash用来检查是否存在：http : //pydash.readthedocs.io/en/latest/api.html#pydash.objects.has

或获取值（您甚至可以设置默认值-如果不存在则返回）：http : //pydash.readthedocs.io/en/latest/api.html#pydash.objects.has

这是一个例子：

>>> get({'a': {'b': {'c': [1, 2, 3, 4]}}}, 'a.b.c[1]')
2

尝试/例外方式是最干净的，没有竞争。但是，它也算作我的IDE中的异常，这会在调试时停止执行。

此外，我不喜欢将异常用作方法内控制语句，这实际上就是try / catch发生的事情。

这是一个不使用递归并且支持默认值的简短解决方案：

def chained_dict_lookup(lookup_dict, keys, default=None):
    _current_level = lookup_dict
    for key in keys:
        if key in _current_level:
            _current_level = _current_level[key]
        else:
            return default
    return _current_level

Python 3.8以上

dictionary = {
    "main_key": {
        "sub_key": "value",
    },
}

if sub_key_value := dictionary.get("main_key", {}).get("sub_key"):
    print(f"The key 'sub_key' exists in dictionary[main_key] and it's value is {sub_key_value}")
else:
    print("Key 'sub_key' doesn't exists")

我建议您使用python-benedict，具有完整keypath支持和许多实用程序方法的可靠python dict子类。

您只需要转换现有的字典即可：

s = benedict(s)

现在，您的字典具有完整的密钥路径支持，您可以使用in运算符检查密钥是否以pythonic方式存在：

if 'mainsnak.datavalue.value.numeric-id' in s:
    # do stuff

这里是库存储库和文档：https : //github.com/fabiocaccamo/python-benedict

注意：我是这个专案的作者

我有同样的问题，最近的python lib弹出了：
https : //pypi.org/project/dictor/
https://github.com/perfecto25/dictor

因此，在您的情况下：

from dictor import dictor

x = dictor(s, 'mainsnak.datavalue.value.numeric-id')

个人说明：
我不喜欢'dictor'这个名字，因为它并不能暗示它实际上在做什么。所以我像这样使用它：

from dictor import dictor as extract
x = extract(s, 'mainsnak.datavalue.value.numeric-id')

没有比更好的名字了extract。如果您提出更可行的命名方式，请随时发表评论。safe_get，robust_get不适合我的情况。

我写了一个数据解析库dataknead来处理这种情况，基本上是因为我对Wikidata API返回的JSON感到沮丧。

有了那个图书馆，你可以做这样的事情

from dataknead import Knead

numid = Knead(s).query("mainsnak/datavalue/value/numeric-id").data()

if numid:
    # Do something with `numeric-id`

如果您可以测试对象路径的字符串表示形式，那么此方法可能对您有用：

def exists(str):
    try:
        eval(str)
        return True
    except:
        return False

exists("lst['sublist']['item']")

其他方式：

def does_nested_key_exists(dictionary, nested_key):
    exists = nested_key in dictionary
    if not exists:
        for key, value in dictionary.items():
            if isinstance(value, dict):
                exists = exists or does_nested_key_exists(value, nested_key)
    return exists