如何使用元组访问深度嵌套的字典? [英] How can I access a deeply nested dictionary using tuples?

问题描述

我想在 nosklo 的上一个答案中给出的>自动生存示例，以允许元组访问字典.

I would like to expand on the autovivification example given in a previous answer from nosklo to allow dictionary access by tuple.

nosklo的解决方案如下:

nosklo's solution looks like this:

class AutoVivification(dict):
    """Implementation of perl's autovivification feature."""
    def __getitem__(self, item):
        try:
            return dict.__getitem__(self, item)
        except KeyError:
            value = self[item] = type(self)()
            return value

测试:

a = AutoVivification()

a[1][2][3] = 4
a[1][3][3] = 5
a[1][2]['test'] = 6

print a

输出:

{1: {2: {'test': 6, 3: 4}, 3: {3: 5}}}

---

在某些情况下，我想设置一个给定任意下标元组的节点.如果我不知道元组有多少层，该如何设计一种方法来设置适当的节点?

---

I have a case where I want to set a node given some arbitrary tuple of subscripts. If I don't know how many layers deep the tuple will be, how can I design a way to set the appropriate node?

我在想，也许我可以使用如下语法:

I'm thinking that perhaps I could use syntax like the following:

mytuple = (1,2,3)
a[mytuple] = 4

但是我很难提出一个可行的实施方案.

But I'm having trouble coming up with a working implementation.

我有一个基于@JCash答案的完整示例:

I have a fully working example based on @JCash's answer:

class NestedDict(dict):
    """                                                                       
    Nested dictionary of arbitrary depth with autovivification.               

    Allows data access via extended slice notation.                           
    """
    def __getitem__(self, keys):
        # Let's assume *keys* is a list or tuple.                             
        if not isinstance(keys, basestring):
            try:
                node = self
                for key in keys:
                    node = dict.__getitem__(node, key)
                return node
            except TypeError:
            # *keys* is not a list or tuple.                              
                pass
        try:
            return dict.__getitem__(self, keys)
        except KeyError:
            raise KeyError(keys)
    def __setitem__(self, keys, value):
        # Let's assume *keys* is a list or tuple.                             
        if not isinstance(keys, basestring):
            try:
                node = self
                for key in keys[:-1]:
                    try:
                        node = dict.__getitem__(node, key)
                    except KeyError:
                        node[key] = type(self)()
                        node = node[key]
                return dict.__setitem__(node, keys[-1], value)
            except TypeError:
                # *keys* is not a list or tuple.                              
                pass
        dict.__setitem__(self, keys, value)

使用扩展的切片符号可以达到与上述相同的输出:

Which can achieve the same output as above using extended slice notation:

d = NestedDict()
d[1,2,3] = 4
d[1,3,3] = 5
d[1,2,'test'] = 6

推荐答案

这似乎可行

def __setitem__(self, key, value):
    if isinstance(key, tuple):
        node = self
        for i in key[:-1]:
            try:
                node = dict.__getitem__(node, i)
            except KeyError:
                node = node[i] = type(self)()
        return dict.__setitem__(node, i, value)
    return dict.__setitem__(self, key, value)

这篇关于如何使用元组访问深度嵌套的字典?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！