我可以把这些都打包到一个类中，但似乎有人已经这样做了。

来自开源ndicts包(我是作者)的NestedDict类试图减轻处理嵌套字典的痛苦。我认为它满足了所有问题的要求。

这里有它的功能概要，要了解更多细节，请查看文档。

初始化

>>> from ndicts import NestedDict
>>> nd = NestedDict({"a": {"aa": 0}, "b": 1})

得到项目

把NestedDict看作是一个扁平的字典。

>>> nd["a", "aa"]
0

同时，您可以获得中间节点，而不仅仅是叶值。

>>> nd["a"]
{"aa": 0}

如果键不存在，则抛出异常。

>>> nd["asd"]
Traceback (most recent call last):
...
KeyError: ('asd',)

设置项

与普通字典一样，如果缺少一个键，则将它添加到NestedDict中。

>>> nd["a", "ab"] = 2
>>> nd
NestedDict({"a": {"aa": 0, "ab": 2}, "b": 1})

这允许从一个空的NestedDict开始，可以通过设置新项来激活它。

迭代

谈到迭代，可以把NestedDict看作是一个扁平的字典。我们熟悉的.keys()， .values()和.item()方法是可用的。

>>> [key for key in nd]
[('a', 'aa'), ('a', 'ab'), ('b',)]
>>> [value for value in nd.values()]
[0, 2, 1]

我发现setdefault非常有用;它检查一个键是否存在，如果不存在就添加它:

d = {}
d.setdefault('new jersey', {}).setdefault('mercer county', {})['plumbers'] = 3

Setdefault总是返回相关的键，所以你实际上是在原地更新'd'的值。

说到迭代，我相信你可以很容易地编写一个生成器，如果Python中还没有这样的生成器:

def iterateStates(d):
    # Let's count up the total number of "plumbers" / "dentists" / etc.
    # across all counties and states
    job_totals = {}

    # I guess this is the annoying nested stuff you were talking about?
    for (state, counties) in d.iteritems():
        for (county, jobs) in counties.iteritems():
            for (job, num) in jobs.iteritems():
                # If job isn't already in job_totals, default it to zero
                job_totals[job] = job_totals.get(job, 0) + num

    # Now return an iterator of (job, number) tuples
    return job_totals.iteritems()

# Display all jobs
for (job, num) in iterateStates(d):
    print "There are %d %s in total" % (job, num)

至于“讨厌的尝试/捕捉障碍”:

d = {}
d.setdefault('key',{}).setdefault('inner key',{})['inner inner key'] = 'value'
print d

收益率

{'key': {'inner key': {'inner inner key': 'value'}}}

你可以使用它从你的平面字典格式转换为结构化格式:

fd = {('new jersey', 'mercer county', 'plumbers'): 3,
 ('new jersey', 'mercer county', 'programmers'): 81,
 ('new jersey', 'middlesex county', 'programmers'): 81,
 ('new jersey', 'middlesex county', 'salesmen'): 62,
 ('new york', 'queens county', 'plumbers'): 9,
 ('new york', 'queens county', 'salesmen'): 36}

for (k1,k2,k3), v in fd.iteritems():
    d.setdefault(k1, {}).setdefault(k2, {})[k3] = v

我喜欢把它包装在一个类中，并实现__getitem__和__setitem__，这样它们就实现了一个简单的查询语言:

>>> d['new jersey/mercer county/plumbers'] = 3
>>> d['new jersey/mercer county/programmers'] = 81
>>> d['new jersey/mercer county/programmers']
81
>>> d['new jersey/mercer country']
<view which implicitly adds 'new jersey/mercer county' to queries/mutations>

如果你想要更花哨，你也可以实现如下内容:

>>> d['*/*/programmers']
<view which would contain 'programmers' entries>

但大多数情况下，我认为这样的事情执行起来真的很有趣:D

在Python中实现嵌套字典的最佳方法是什么?

这是个坏主意，别这么做。相反，使用普通的字典和字典。因此，当正常使用下缺少键时，您将获得预期的KeyError。如果你坚持这种行为，下面是搬起石头砸自己的脚的方法:

在dict子类上实现__missing__来设置并返回一个新实例。

这种方法自Python 2.5以来就已经可用(并有文档)，并且(对我来说特别有价值)它像普通的dict一样漂亮地打印，而不是像autovivified defaultdict那样难看地打印:

class Vividict(dict):
    def __missing__(self, key):
        value = self[key] = type(self)() # retain local pointer to value
        return value                     # faster to return than dict lookup

(注意self[key]在赋值的左边，所以这里没有递归。)

假设你有一些数据:

data = {('new jersey', 'mercer county', 'plumbers'): 3,
        ('new jersey', 'mercer county', 'programmers'): 81,
        ('new jersey', 'middlesex county', 'programmers'): 81,
        ('new jersey', 'middlesex county', 'salesmen'): 62,
        ('new york', 'queens county', 'plumbers'): 9,
        ('new york', 'queens county', 'salesmen'): 36}

下面是我们的用法代码:

vividict = Vividict()
for (state, county, occupation), number in data.items():
    vividict[state][county][occupation] = number

现在:

>>> import pprint
>>> pprint.pprint(vividict, width=40)
{'new jersey': {'mercer county': {'plumbers': 3,
                                  'programmers': 81},
                'middlesex county': {'programmers': 81,
                                     'salesmen': 62}},
 'new york': {'queens county': {'plumbers': 9,
                                'salesmen': 36}}}

批评

对这种类型的容器的批评是，如果用户拼写错了一个键，我们的代码可能会无声地失败:

>>> vividict['new york']['queens counyt']
{}

另外，现在我们的数据中有一个拼错的county:

>>> pprint.pprint(vividict, width=40)
{'new jersey': {'mercer county': {'plumbers': 3,
                                  'programmers': 81},
                'middlesex county': {'programmers': 81,
                                     'salesmen': 62}},
 'new york': {'queens county': {'plumbers': 9,
                                'salesmen': 36},
              'queens counyt': {}}}

解释:

我们只是提供了类的另一个嵌套实例，每当一个键被访问但缺失时。(返回赋值是有用的，因为它避免了我们额外调用dict上的getter，不幸的是，我们不能在它被设置时返回它。)

注意，这些和被点赞最多的答案是相同的语义，但是只有一半的代码行——nosklo的实现:

类AutoVivification (dict类型): "" perl的自动激活功能的实现。"＂＂ Def __getitem__(self, item): 试一试: 返回dict类型。__getitem__(自我,项) 除了KeyError: Value = self[item] = type(self)() 返回值

使用说明

下面是一个示例，说明如何轻松地使用这个字典创建一个嵌套的字典结构。这可以快速创建您想要深入的层次树结构。

import pprint

class Vividict(dict):
    def __missing__(self, key):
        value = self[key] = type(self)()
        return value

d = Vividict()

d['foo']['bar']
d['foo']['baz']
d['fizz']['buzz']
d['primary']['secondary']['tertiary']['quaternary']
pprint.pprint(d)

输出:

{'fizz': {'buzz': {}},
 'foo': {'bar': {}, 'baz': {}},
 'primary': {'secondary': {'tertiary': {'quaternary': {}}}}}

正如最后一行所示，它打印得非常漂亮，便于人工检查。但如果你想要可视化地检查你的数据，实现__missing__来设置它的类的一个新实例为键并返回它是一个更好的解决方案。

作为对比，其他选择:

dict.setdefault

尽管提问者认为这个不干净，但我觉得它比我自己的livelict更可取。

d = {} # or dict()
for (state, county, occupation), number in data.items():
    d.setdefault(state, {}).setdefault(county, {})[occupation] = number

现在:

>>> pprint.pprint(d, width=40)
{'new jersey': {'mercer county': {'plumbers': 3,
                                  'programmers': 81},
                'middlesex county': {'programmers': 81,
                                     'salesmen': 62}},
 'new york': {'queens county': {'plumbers': 9,
                                'salesmen': 36}}}

一个拼写错误会引起混乱，也不会让我们的数据充满错误信息:

>>> d['new york']['queens counyt']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'queens counyt'

此外，我认为setdefault在循环中使用时工作得很好，你不知道你将得到什么键，但重复使用变得相当繁重，我不认为任何人会想要保持以下:

d = dict()

d.setdefault('foo', {}).setdefault('bar', {})
d.setdefault('foo', {}).setdefault('baz', {})
d.setdefault('fizz', {}).setdefault('buzz', {})
d.setdefault('primary', {}).setdefault('secondary', {}).setdefault('tertiary', {}).setdefault('quaternary', {})

另一个批评是，无论是否使用setdefault，它都需要一个新实例。然而，Python(或者至少是CPython)在处理未使用和未引用的新实例方面相当聪明，例如，它重用内存中的位置:

>>> id({}), id({}), id({})
(523575344, 523575344, 523575344)

一个自动激活的defaultdict

这是一个整洁的实现，在你没有检查数据的脚本中使用与实现__missing__一样有用:

from collections import defaultdict

def vivdict():
    return defaultdict(vivdict)

但是如果你需要检查你的数据，一个自动激活的defaultdict以同样的方式填充数据的结果看起来像这样:

>>> d = vivdict(); d['foo']['bar']; d['foo']['baz']; d['fizz']['buzz']; d['primary']['secondary']['tertiary']['quaternary']; import pprint; 
>>> pprint.pprint(d)
defaultdict(<function vivdict at 0x17B01870>, {'foo': defaultdict(<function vivdict 
at 0x17B01870>, {'baz': defaultdict(<function vivdict at 0x17B01870>, {}), 'bar': 
defaultdict(<function vivdict at 0x17B01870>, {})}), 'primary': defaultdict(<function 
vivdict at 0x17B01870>, {'secondary': defaultdict(<function vivdict at 0x17B01870>, 
{'tertiary': defaultdict(<function vivdict at 0x17B01870>, {'quaternary': defaultdict(
<function vivdict at 0x17B01870>, {})})})}), 'fizz': defaultdict(<function vivdict at 
0x17B01870>, {'buzz': defaultdict(<function vivdict at 0x17B01870>, {})})})

这个输出非常不美观，结果也非常难以阅读。通常给出的解决方案是递归地转换回字典以供人工检查。这个非平凡的解留给读者作为练习。

性能

最后，让我们看看性能。减去实例化的代价。

>>> import timeit
>>> min(timeit.repeat(lambda: {}.setdefault('foo', {}))) - min(timeit.repeat(lambda: {}))
0.13612580299377441
>>> min(timeit.repeat(lambda: vivdict()['foo'])) - min(timeit.repeat(lambda: vivdict()))
0.2936999797821045
>>> min(timeit.repeat(lambda: Vividict()['foo'])) - min(timeit.repeat(lambda: Vividict()))
0.5354437828063965
>>> min(timeit.repeat(lambda: AutoVivification()['foo'])) - min(timeit.repeat(lambda: AutoVivification()))
2.138362169265747

基于性能，dict。Setdefault的效果最好。在关心执行速度的情况下，我强烈推荐它用于生产代码。

如果你需要它来进行交互使用(也许在IPython笔记本中)，那么性能并不重要——在这种情况下，为了输出的可读性，我会选择vivid。与AutoVivification对象(它使用__getitem__而不是__missing__，后者是为此目的而创建的)相比，它要优越得多。

结论

在子类dict上实现__missing__来设置并返回一个新实例比其他方法稍微困难一些，但具有的优点

简单的实例化 简单的数据填充 轻松查看数据

因为它比修改__getitem__更简单，性能更好，所以应该优先使用该方法。

然而，它也有缺点:

错误的查找将会无声地失败。 错误的查找将保留在字典中。

因此，与其他解决方案相比，我个人更喜欢使用setdefault，并且在需要这种行为的每种情况下都使用它。

由于您有一个星型模式设计，您可能希望它的结构更像一个关系表，而不是字典。

import collections

class Jobs( object ):
    def __init__( self, state, county, title, count ):
        self.state= state
        self.count= county
        self.title= title
        self.count= count

facts = [
    Jobs( 'new jersey', 'mercer county', 'plumbers', 3 ),
    ...

def groupBy( facts, name ):
    total= collections.defaultdict( int )
    for f in facts:
        key= getattr( f, name )
        total[key] += f.count

这类事情对于创建一个没有SQL开销的类似数据仓库的设计大有帮助。