Python 在有序默认字典中重写

我有一个有点复杂的数据结构：一个默认的有序字典的有序字典，遵循代码。该类工作正常，因为如果缺少键，我可以在默认情况下创建有序字典。我想进一步扩展这个类的功能，并重写

\uuuuu iter\uuuu

方法，这样我就可以只遍历某个键的有序字典。也就是说，如果我有

import sys
import numpy as np
from collections import OrderedDict


class OrderedDefaultdict(OrderedDict):
    def __init__(self, *args, **kwargs):

        self.d = None
        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 __iter__(self):
        for k in self[self.d].values():
            yield k

    def __call__(self, key):
        self.d = key
        return self

    def __missing__ (self, key):

        self.d = max(self.d, key) if self.d else 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)

您可以看到，代码将最大键保存在变量

self.d

中，默认情况下，我希望迭代它对应的字典

def main(argv=()):

    tree = Tree()

    tree[0]['n1'] = np.array([[3]])
    tree[1]['l2'] = np.array([[ 0,  4],
                            [ 4,  5],
                            [40, 41],
                            [41, 42],
                            [57,  3],
                            [57,  3]])
    tree[2]['t3x'] = np.array([[188, 401, 400],
                           [188, 187, 401],
                           [187, 205, 401],
                           [324, 306, 417],
                           [306, 305, 417],
                           [305, 416, 417]])
    tree[2]['q3'] = np.array([[188, 401, 400, 0],
                           [188, 187, 401, 0],
                           [187, 205, 401, 0],
                           [323, 324, 417, 0],
                           [324, 306, 417, 0],
                           [306, 305, 417, 0],
                           [305, 416, 417, 0]])

    for el in tree:
        print(el)

    return 0

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

---

在上面的代码中，我尝试迭代最高维度的字典。但是这段代码不起作用，因为我在

\uuu iter\uuu

方法中遇到了无限递归，我不明白为什么。我一直在遵循关于如何实现此功能的建议。

在第一个代码块的末尾：

Tree=lambda:OrderedDefaultdict（Tree）

您的意思是在OrderedDict中为k提供

。\uu iter（self[self.d]）：产生self[self d][k]

是的！这是有效的，但为什么呢？这里有严重的触摸板问题，这本质上是用

super（OrderedDefaultdict，self）覆盖像getitem这样的东西之间的区别。你调用的
self中的k是
vs
return self[self.d]
__iter__;
这样你就得到了一个无限递归