对于嵌套的字典/JSON查找，可以使用dictor

PIP安装指示器

dict对象

{
    "characters": {
        "Lonestar": {
            "id": 55923,
            "role": "renegade",
            "items": [
                "space winnebago",
                "leather jacket"
            ]
        },
        "Barfolomew": {
            "id": 55924,
            "role": "mawg",
            "items": [
                "peanut butter jar",
                "waggy tail"
            ]
        },
        "Dark Helmet": {
            "id": 99999,
            "role": "Good is dumb",
            "items": [
                "Shwartz",
                "helmet"
            ]
        },
        "Skroob": {
            "id": 12345,
            "role": "Spaceballs CEO",
            "items": [
                "luggage"
            ]
        }
    }
}

要获得龙星的物品，只需提供一个点分隔的路径，即

import json
from dictor import dictor

with open('test.json') as data: 
    data = json.load(data)

print dictor(data, 'characters.Lonestar.items')

>> [u'space winnebago', u'leather jacket']

如果键不在路径中，您可以提供回退值

你还有很多选择，比如忽略字母大小写，使用'以外的其他字符。作为路径分隔符，

https://github.com/perfecto25/dictor

你可以使用get两次:

example_dict.get('key1', {}).get('key2')

如果key1或key2不存在，则返回None。

注意，如果example_dict['key1']存在但不是dict(或具有get方法的类dict对象)，仍然可能引发AttributeError。如果example_dict['key1']不可下标，你发布的try..except代码将引发TypeError。

另一个区别是try…除非在第一次丢失钥匙后立即发生短路。get调用链则不然。

如果您希望保留语法example_dict['key1']['key2']，但不希望它引发KeyErrors，那么您可以使用哈希recipe:

class Hasher(dict):
    # https://stackoverflow.com/a/3405143/190597
    def __missing__(self, key):
        value = self[key] = type(self)()
        return value

example_dict = Hasher()
print(example_dict['key1'])
# {}
print(example_dict['key1']['key2'])
# {}
print(type(example_dict['key1']['key2']))
# <class '__main__.Hasher'>

注意，当缺少一个键时，返回一个空的hash。

因为Hasher是dict的一个子类，你可以像使用dict一样使用Hasher。所有相同的方法和语法都是可用的，哈希器只是以不同的方式对待缺失的键。

你可以像这样把一个普通字典转换成哈希:

hasher = Hasher(example_dict)

并将哈希转换为普通字典一样容易:

regular_dict = dict(hasher)

另一种选择是在helper函数中隐藏丑陋的代码:

def safeget(dct, *keys):
    for key in keys:
        try:
            dct = dct[key]
        except KeyError:
            return None
    return dct

这样你剩下的代码就可以保持相对的可读性:

safeget(example_dict, 'key1', 'key2')

在第一阶段，你可以得到一个空字典。

example_dict.get('key1',{}).get('key2')

一个简单的类，可以包装字典，并根据键进行检索:

class FindKey(dict):
    def get(self, path, default=None):
        keys = path.split(".")
        val = None

        for key in keys:
            if val:
                if isinstance(val, list):
                    val = [v.get(key, default) if v else None for v in val]
                else:
                    val = val.get(key, default)
            else:
                val = dict.get(self, key, default)

            if not val:
                break

        return val

例如:

person = {'person':{'name':{'first':'John'}}}
FindDict(person).get('person.name.first') # == 'John'

如果该键不存在，则默认返回None。你可以在FindDict包装器中使用default=键覆盖它，例如':

FindDict(person, default='').get('person.name.last') # == doesn't exist, so ''

你也可以使用python reduce:

def deep_get(dictionary, *keys):
    return reduce(lambda d, key: d.get(key) if d else None, keys, dictionary)

对于二级键检索，你可以这样做:

key2_value = (example_dict.get('key1') or {}).get('key2')