python中有序字典的有序字典

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

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

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

UPDATE

这就是我到目前为止想到的：

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]比字典上的原始迭代效率低。这是真的？我该如何改进这个？

这是另一种使用OrderedDefaultdict定义您想要的树状数据结构。我正在重用另一个人的定义answer https://stackoverflow.com/questions/4126348/how-do-i-rewrite-this-function-to-implement-ordereddict/4127426#4127426我的。

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

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().)