您可以在每个字典上使用 get()。请确保已为每次访问添加了 None 检查。

.get 不是用于事后检查返回值是否为 None 的，你也可以只检查键是否在字典中：key in dict 或旧版本 dict.has_key

tmpDict.get('ONE', {}).get('TWO', {}).get('THREE') 使用 get 以空字典作为默认...如果三个键中的任何一个不存在，它将返回 None

@dav1d 为什么你说 .get 不是用来事后检查返回值是否为 None 的？否则为什么会有这种方法？

与 Python 中其他方法一样，当然有多种方法可以实现这一点，但 有一种显而易见的方法可以实现这一点。

tmpdict["ONE"]["TWO"]["THREE"] 是 显而易见的方法。

如果这与您的算法不太契合，这可能暗示您的结构不是最适合解决问题的。

如果你只是想节省重复输入的时间，你当然可以为字典的子集设置别名：

>>> two_dict = tmpdict['ONE']['TWO'] # now you can just write two_dict for tmpdict['ONE']['TWO']
>>> two_dict["spam"] = 23
>>> tmpdict
{'ONE': {'TWO': {'THREE': 10, 'spam': 23}}}

确实，通过 [] 运算符访问字典元素是一种显而易见的方法。但我强烈建议您也阅读这个相关问题的答案。在现实场景中，必须将“路径”（可能是可变长度）传递给（可能深度）嵌套字典中的元素，而在每个中间字典上调用 get() 或 [] 运算符会很麻烦。

但是，您不能为别名设置别名，因此，如果您打算以递归方式多次执行该过程，则必须拥有密钥，否则它将第二次按值传递。

我的实现：

def get_nested(data, *args):
    if args and data:
        element  = args[0]
        if element:
            value = data.get(element)
            return value if len(args) == 1 else get_nested(value, *args[1:])

使用示例：

>>> dct={"foo":{"bar":{"one":1, "two":2}, "misc":[1,2,3]}, "foo2":123}
>>> get_nested(dct, "foo", "bar", "one")
1
>>> get_nested(dct, "foo", "bar", "two")
2
>>> get_nested(dct, "foo", "misc")
[1, 2, 3]
>>> get_nested(dct, "foo", "missing")
>>>

如果缺少密钥，则不会引发异常，在这种情况下不会返回任何值。

Sivasubramaniam Arunachalam 或 ch3ka 已经给出了答案。

我只是想添加答案的性能视图。

dicttest={}
dicttest['ligne1']={'ligne1.1':'test','ligne1.2':'test8'}
%timeit dicttest['ligne1']['ligne1.1']
%timeit dicttest.get('ligne1').get('ligne1.1')

得到：

每循环 112 ns ± 29.7 ns（7 次运行的平均值 ± 标准差，每次 10000000 个循环）

每循环 235 ns ± 9.82 ns（7 次运行的平均值 ± 标准差，每次 1000000 次循环）

不，那些是嵌套字典，所以这是唯一真正的方法（您可以使用， get() 但本质上是一样的）。但是，还有另一种选择。您可以使用元组作为键，而不是使用嵌套字典：

tempDict = {("ONE", "TWO", "THREE"): 10}
tempDict["ONE", "TWO", "THREE"]

这确实有一个缺点，例如，没有（简单而快速的）方法来获取所有元素 "TWO" ，但如果这不重要，这可能是一个很好的解决方案。

我不太清楚这在实际应用中有什么好处。如果你的数据是结构化的，那么将其扁平化并增加密钥复杂性似乎并没有真正增加价值。

@sr2222 这意味着您不必拥有大量的字典，这意味着您不必担心在添加新值时创建子字典，并且根据应用程序的不同，这可能会更自然。我认为在某些情况下这足以值得。