python - python中有序字典的有序字典

Question

我需要一个字典数据结构来存储字典，如下所示:

custom = {1: {'a': np.zeros(10), 'b': np.zeros(100)}, 
          2: {'c': np.zeros(20), 'd': np.zeros(200)}}

但问题是我在我的代码中多次迭代这个数据结构。每次我迭代它时，我都需要遵守迭代顺序，因为这个复杂数据结构中的所有元素都映射到一维数组(如果你愿意，可以序列化)，因此顺序很重要。我考虑过为此写一个有序 dict 的有序 dict，但我不确定这是正确的解决方案，因为我似乎选择了错误的数据结构.什么是最适合我的情况的解决方案？

更新

这就是我到目前为止想出的:

class Test(list):

    def __init__(self, *args, **kwargs):

        super(Test, self).__init__(*args, **kwargs)

        for k,v in args[0].items():
            self[k] = OrderedDict(v)

        self.d = -1
        self.iterator = iter(self[-1].keys())
        self.etype = next(self.iterator)
        self.idx = 0


    def __iter__(self):
        return self

    def __next__(self):

        try:
            self.idx += 1
            return self[self.d][self.etype][self.idx-1]

        except IndexError:

            self.etype = next(self.iterator)
            self.idx = 0
            return self[self.d][self.etype][self.idx-1]

    def __call__(self, d):

        self.d = -1 - d
        self.iterator = iter(self[self.d].keys())
        self.etype = next(self.iterator)
        self.idx = 0
        return self


def main(argv=()):

    tst = Test(elements)
    for el in tst:
        print(el)
    # loop over a lower dimension
    for el in tst(-2):
        print(el)

    print(tst)


    return 0

if __name__ == "__main__":
    sys.exit(main())

我可以在这个有序结构中迭代任意多次，并且我实现了 __call__ 所以我可以迭代较低的维度。我不喜欢这样的事实，即如果列表中不存在较低的维度，它不会给我任何错误。我还觉得每次调用 return self[self.d][self.etype][self.idx-1] 的效率都低于字典的原始迭代。这是真的？我该如何改进？

Answer 1

这是另一种选择，它使用 OrderedDefaultdict 来定义您想要的树状数据结构。我正在重用另一个 answer 中的定义我的。

要使用它，您必须确保条目是按照您希望稍后访问它们的顺序定义的。

class OrderedDefaultdict(OrderedDict):
    def __init__(self, *args, **kwargs):
        if not args:
            self.default_factory = None
        else:
            if not (args[0] is None or callable(args[0])):
                raise TypeError('first argument must be callable or None')
            self.default_factory = args[0]
            args = args[1:]
        super(OrderedDefaultdict, self).__init__(*args, **kwargs)

    def __missing__ (self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = default = self.default_factory()
        return default

    def __reduce__(self):  # optional, for pickle support
        args = (self.default_factory,) if self.default_factory else ()
        return self.__class__, args, None, None, self.iteritems()

Tree = lambda: OrderedDefaultdict(Tree)

custom = Tree()
custom[1]['a'] = np.zeros(10)
custom[1]['b'] = np.zeros(100)
custom[2]['c'] = np.zeros(20)
custom[2]['d'] = np.zeros(200)

我不确定我是否理解您的后续问题。如果数据结构限于两层，您可以使用嵌套的 for 循环按照元素定义的顺序迭代其元素。例如:

for key1, subtree in custom.items():
    for key2, elem in subtree.items():
        print('custom[{!r}][{!r}]: {}'.format(key1, key2, elem))

(在 Python 2 中，您需要使用 iteritems() 而不是 items()。)