问题：Python：defaultdict的defaultdict？
有没有一种方法可以defaultdict(defaultdict(int))使以下代码正常工作？
for x in stuff:
d[x.a][x.b] += x.c_int
d需要临时构建，具体取决于x.a和x.b元素。
我可以使用：
for x in stuff:
d[x.a,x.b] += x.c_int
但后来我将无法使用：
d.keys()
d[x.a].keys()
Is there a way to have a defaultdict(defaultdict(int)) in order to make the following code work?
for x in stuff:
d[x.a][x.b] += x.c_int
d needs to be built ad-hoc, depending on x.a and x.b elements.
I could use:
for x in stuff:
d[x.a,x.b] += x.c_int
but then I wouldn’t be able to use:
d.keys()
d[x.a].keys()
回答 0
是这样的：
defaultdict(lambda: defaultdict(int))
当您尝试访问不存在的键时，将调用的参数defaultdict（在这种情况下为lambda: defaultdict(int)）。它的返回值将设置为该密钥的新值，这意味着在我们的情况下，d[Key_doesnt_exist]将为defaultdict(int)。
如果尝试从最后一个defaultdict访问密钥，即d[Key_doesnt_exist][Key_doesnt_exist]它将返回0，这是最后一个defaultdict的参数的返回值int()。
Yes like this:
defaultdict(lambda: defaultdict(int))
The argument of a defaultdict (in this case is lambda: defaultdict(int)) will be called when you try to access a key that doesn’t exist. The return value of it will be set as the new value of this key, which means in our case the value of d[Key_doesnt_exist] will be defaultdict(int).
If you try to access a key from this last defaultdict i.e. d[Key_doesnt_exist][Key_doesnt_exist] it will return 0, which is the return value of the argument of the last defaultdict i.e. int().
回答 1
defaultdict构造函数的参数是用于构建新元素的函数。因此，让我们使用lambda！
>>> from collections import defaultdict
>>> d = defaultdict(lambda : defaultdict(int))
>>> print d[0]
defaultdict(<type 'int'>, {})
>>> print d[0]["x"]
0
从Python 2.7开始，使用Counter有了一个更好的解决方案：
>>> from collections import Counter
>>> c = Counter()
>>> c["goodbye"]+=1
>>> c["and thank you"]=42
>>> c["for the fish"]-=5
>>> c
Counter({'and thank you': 42, 'goodbye': 1, 'for the fish': -5})
一些额外功能
>>> c.most_common()[:2]
[('and thank you', 42), ('goodbye', 1)]
有关更多信息，请参见PyMOTW-集合-容器数据类型和Python文档-集合
The parameter to the defaultdict constructor is the function which will be called for building new elements. So let’s use a lambda !
>>> from collections import defaultdict
>>> d = defaultdict(lambda : defaultdict(int))
>>> print d[0]
defaultdict(<type 'int'>, {})
>>> print d[0]["x"]
0
Since Python 2.7, there’s an even better solution using Counter:
>>> from collections import Counter
>>> c = Counter()
>>> c["goodbye"]+=1
>>> c["and thank you"]=42
>>> c["for the fish"]-=5
>>> c
Counter({'and thank you': 42, 'goodbye': 1, 'for the fish': -5})
Some bonus features
>>> c.most_common()[:2]
[('and thank you', 42), ('goodbye', 1)]
For more information see PyMOTW – Collections – Container data types and Python Documentation – collections
回答 2
我发现使用起来稍微更优雅partial：
import functools
dd_int = functools.partial(defaultdict, int)
defaultdict(dd_int)
当然，这与lambda相同。
I find it slightly more elegant to use partial:
import functools
dd_int = functools.partial(defaultdict, int)
defaultdict(dd_int)
Of course, this is the same as a lambda.
回答 3
作为参考，可以通过以下方式实现通用的嵌套defaultdict工厂方法：
from collections import defaultdict
from functools import partial
from itertools import repeat
def nested_defaultdict(default_factory, depth=1):
result = partial(defaultdict, default_factory)
for _ in repeat(None, depth - 1):
result = partial(defaultdict, result)
return result()
深度定义了default_factory使用中定义的类型之前嵌套字典的数量。例如：
my_dict = nested_defaultdict(list, 3)
my_dict['a']['b']['c'].append('e')
For reference, it’s possible to implement a generic nested defaultdict factory method through:
from collections import defaultdict
from functools import partial
from itertools import repeat
def nested_defaultdict(default_factory, depth=1):
result = partial(defaultdict, default_factory)
for _ in repeat(None, depth - 1):
result = partial(defaultdict, result)
return result()
The depth defines the number of nested dictionary before the type defined in default_factory is used.
For example:
my_dict = nested_defaultdict(list, 3)
my_dict['a']['b']['c'].append('e')
回答 4
先前的答案已经解决了如何制作两级或n级defaultdict。在某些情况下，您需要无限个：
def ddict():
return defaultdict(ddict)
用法：
>>> d = ddict()
>>> d[1]['a'][True] = 0.5
>>> d[1]['b'] = 3
>>> import pprint; pprint.pprint(d)
defaultdict(<function ddict at 0x7fcac68bf048>,
{1: defaultdict(<function ddict at 0x7fcac68bf048>,
{'a': defaultdict(<function ddict at 0x7fcac68bf048>,
{True: 0.5}),
'b': 3})})
Previous answers have addressed how to make a two-levels or n-levels defaultdict. In some cases you want an infinite one:
def ddict():
return defaultdict(ddict)
Usage:
>>> d = ddict()
>>> d[1]['a'][True] = 0.5
>>> d[1]['b'] = 3
>>> import pprint; pprint.pprint(d)
defaultdict(<function ddict at 0x7fcac68bf048>,
{1: defaultdict(<function ddict at 0x7fcac68bf048>,
{'a': defaultdict(<function ddict at 0x7fcac68bf048>,
{True: 0.5}),
'b': 3})})
回答 5
其他人已经正确回答了您如何使以下各项正常工作的问题：
for x in stuff:
d[x.a][x.b] += x.c_int
一种替代方法是使用元组作为键：
d = defaultdict(int)
for x in stuff:
d[x.a,x.b] += x.c_int
# ^^^^^^^ tuple key
这种方法的好处是它很简单并且可以轻松扩展。如果您需要三个层次的映射，只需使用一个三项元组作为键。
Others have answered correctly your question of how to get the following to work:
for x in stuff:
d[x.a][x.b] += x.c_int
An alternative would be to use tuples for keys:
d = defaultdict(int)
for x in stuff:
d[x.a,x.b] += x.c_int
# ^^^^^^^ tuple key
The nice thing about this approach is that it is simple and can be easily expanded. If you need a mapping three levels deep, just use a three item tuple for the key.
