defaultdict 的嵌套 defaultdict

Question

有没有办法让defaultdict也成为defaultdict的默认值？（即无限级递归defaultdict？）

我希望能够做到：

x = defaultdict(...stuff...)
x[0][1][0]
{}

所以，我可以做到

x = defaultdict(defaultdict)

，但这只是第二个级别：

x[0]
{}
x[0][0]
KeyError: 0

有一些食谱可以做到这一点。但是可以简单地使用普通的 defaultdict 参数来完成吗？

注意，这是询问如何执行无限级递归defaultdict，因此它与Python：defaultdict of defaultdict？不同，这是如何执行两级defaultdict。

我可能最终会使用bunch模式，但是当我意识到我不知道如何做到这一点时，它引起了我的兴趣。

Answer 1

这里的其他答案告诉您如何创建一个包含“无限多个”

defaultdict

的

defaultdict

，但它们未能解决我认为可能是您最初的需求，即简单地有一个两层深度的defaultdict。

您可能一直在寻找：

defaultdict(lambda: defaultdict(dict))

您可能更喜欢这种结构的原因是：

它比递归解决方案更明确，因此可能更容易被读者理解。

这使得

defaultdict

的“叶子”可以是字典以外的东西，例如：

defaultdict(lambda: defaultdict(list))

或

defaultdict(lambda: defaultdict(set))

Answer 2

对于任意数量的级别：

def rec_dd():
    return defaultdict(rec_dd)

>>> x = rec_dd()
>>> x['a']['b']['c']['d']
defaultdict(<function rec_dd at 0x7f0dcef81500>, {})
>>> print json.dumps(x)
{"a": {"b": {"c": {"d": {}}}}}

当然你也可以使用 lambda 来做到这一点，但我发现 lambda 的可读性较差。无论如何，它看起来像这样：

rec_dd = lambda: defaultdict(rec_dd)

Answer 3

有一个巧妙的技巧可以做到这一点：

tree = lambda: defaultdict(tree)

然后您可以使用

创建您的

x = tree()

。

Answer 4

与 BrenBarn 的解决方案类似，但不包含变量名称

tree

两次，因此即使在更改变量字典后它也能工作：

tree = (lambda f: f(f))(lambda a: (lambda: defaultdict(a(a))))

然后您可以使用

创建每个新的

x = tree()

。

对于

def

版本，我们可以使用函数闭包作用域来保护数据结构免受当

tree

名称反弹时现有实例停止工作的缺陷。看起来像这样：

from collections import defaultdict

def tree():
    def the_tree():
        return defaultdict(the_tree)
    return the_tree()

Answer 5

我还建议更多的 OOP 风格的实现，它支持无限嵌套以及正确的格式

repr

。

class NestedDefaultDict(defaultdict):
    def __init__(self, *args, **kwargs):
        super(NestedDefaultDict, self).__init__(NestedDefaultDict, *args, **kwargs)

    def __repr__(self):
        return repr(dict(self))

用途：

my_dict = NestedDefaultDict()
my_dict['a']['b'] = 1
my_dict['a']['c']['d'] = 2
my_dict['b']

print(my_dict)  # {'a': {'b': 1, 'c': {'d': 2}}, 'b': {}}

Answer 6

我在此基于安德鲁的答案。如果您希望将数据从 json 或现有字典加载到嵌套默认字典中，请参阅此示例：

def nested_defaultdict(existing=None, **kwargs):
    if existing is None:
        existing = {}
    if not isinstance(existing, dict):
        return existing
    existing = {key: nested_defaultdict(val) for key, val in existing.items()}
    return defaultdict(nested_defaultdict, existing, **kwargs)

https://gist.github.com/nucklehead/2d29628bb49115f3c30e78c071207775

Answer 7

这是一个用于任意嵌套深度的任意基本默认字典的函数。

（来自Can't pickle defaultdict的交叉发布）

def wrap_defaultdict(instance, times=1):
    """Wrap an instance an arbitrary number of `times` to create nested defaultdict.
    
    Parameters
    ----------
    instance - list, dict, int, collections.Counter
    times - the number of nested keys above `instance`; if `times=3` dd[one][two][three] = instance
    
    Notes
    -----
    using `x.copy` allows pickling (loading to ipyparallel cluster or pkldump)
        - thanks https://stackoverflow.com/questions/16439301/cant-pickle-defaultdict
    """
    from collections import defaultdict

    def _dd(x):
        return defaultdict(x.copy)

    dd = defaultdict(instance)
    for i in range(times-1):
        dd = _dd(dd)

    return dd

Answer 8

但是，根据 Chris W 的回答，为了解决类型注释问题，您可以将其设为定义详细类型的工厂函数。例如，这是我研究这个问题时问题的最终解决方案：

def frequency_map_factory() -> dict[str, dict[str, int]]:
    """
    Provides a recorder of: per X:str, frequency of Y:str occurrences.
    """
    return defaultdict(lambda: defaultdict(int))

Answer 9

这里是一个递归函数，用于将递归默认字典转换为普通字典

def defdict_to_dict(defdict, finaldict):
    # pass in an empty dict for finaldict
    for k, v in defdict.items():
        if isinstance(v, defaultdict):
            # new level created and that is the new value
            finaldict[k] = defdict_to_dict(v, {})
        else:
            finaldict[k] = v
    return finaldict

defdict_to_dict(my_rec_default_dict, {})

Answer 10

@nucklehead 的 response 也可以扩展来处理 JSON 中的数组：

def nested_dict(existing=None, **kwargs):
    if existing is None:
        existing = defaultdict()
    if isinstance(existing, list):
        existing = [nested_dict(val) for val in existing]
    if not isinstance(existing, dict):
        return existing
    existing = {key: nested_dict(val) for key, val in existing.items()}
    return defaultdict(nested_dict, existing, **kwargs)

Answer 11

这是一个类似于 @Stanislav 的答案的解决方案，它适用于多处理，并且还允许终止嵌套：

from collections import defaultdict
from functools import partial

class NestedDD(defaultdict):
    def __init__(self, n, *args, **kwargs):
        self.n = n
        factory = partial(build_nested_dd, n=n - 1) if n > 1 else int
        super().__init__(factory, *args, **kwargs)

    def __repr__(self):
        return repr(dict(self))

def build_nested_dd(n):
    return NestedDD(n)

Answer 12

这里有一个类似于@Chris W.的解决方案，它使更多级别成为可能。它仍然允许将“叶子”指定为除 defaultdict 之外的其他内容。

定义了一个闭包，而不是 lambda。

您可能更喜欢这种方法，因为，

嵌套 defaultdict 的声明被编写为嵌套函数，因此可能更容易阅读。
可以有两个以上的级别。
最后一个叶子可以是：列表，集合，...

这是一个例子。

from collections import defaultdict
import json

def another_defaultdict(factory):
    'return another layer of defaultdict as a factory function'
    def layer():
        return defaultdict(factory)  
    return layer




>>> # two levels
>>> d = defaultdict(another_defaultdict(list))

>>> # three levels
>>> d = defaultdict(another_defaultdict(another_defaultdict(list)))


>>> d['Canada']['Alberta'] = ['Calgary', 'Magrath', 'Cardston', 'Lethbridge']
>>> d['France']['Nord'] = ['Dunkirk', 'Croix']
>>> print(json.dumps(d, indent=2))
{
  "Canada": {
    "Alberta": [
      "Calgary",
      "Magrath",
      "Cardston",
      "Lethbridge"
    ]
  },
  "France": {
    "Nord": [
      "Dunkirk",
      "Croix"
    ]
  }
}

defaultdict 的嵌套 defaultdict

问题描述投票：0回答：12

12个回答

最新问题

defaultdict 的嵌套 defaultdict

问题描述 投票：0回答：12

12个回答

最新问题

问题描述投票：0回答：12