Question

我有许多类都是从彼此继承的，每个类都需要为definitions属性提供一些字典项。

例如：

class A(object):
    definitions = None
    def __init__(self):
        self.definitions = {}
        self.definitions.get_parent_definitions()
        self.definitions.update(self.get_definitions())

    def get_parent_definitions(self):
        if self.__class__ != A:
             self.definitions.update(
                 super(self.__class__, self).get_parent_definitions())
        self.definitions.update(self.get_definitions())

    def get_definitions(self):
        return {
            'A' : 1,
        }

class B(A) :
    def get_definitions(self):
        return {
            'B' : 22,
        }

class CA(B):
    def get_definitions(self):
        return {
            'C' : 333,
        }

class CB(B):
    def get_definitions(self):
        return {
            'C' : 444,
        }

这会导致错误RuntimeError: maximum recursion depth exceeded in cmp毫不奇怪。

最终目标是我留下以下定义：

CA.definitions = {
     'A' : 1,
     'B' : 22,
     'C' : 333,
}

CB.definitions = {
     'A' : 1,
     'B' : 22,
     'C' : 444,
}

以这种方式安排代码的主要目的是尽量避免在super的任何子类中调用A，因为我预计需要相当多的子代码类。这可能吗？

Answer 1

我不确定我是否理解你，但也许这就是你的意思：

class A(object):
    def __init__(self):
        self.definitions = self.get_all_definitions()

    @classmethod
    def get_all_definitions(cls):
        dct = {}
        while True:
            dct.update(cls.get_definitions())
            if cls == A:
                return dct
            else:
                cls = cls.__bases__[0] # only first parent class is considered
                                       # multiple inheritance is not supported

    @classmethod
    def get_definitions(cls):
        return {'A' : 1}

class B(A):
    @classmethod
    def get_definitions(cls):
        return {'B' : 22}

class CA(B):
    @classmethod
    def get_definitions(cls):
        return {'C' : 333}

class CB(B):
    @classmethod
    def get_definitions(cls):
        return {'C' : 444}

# Test
ca = CA()
print ca.definitions

cb = CB()
print cb.definitions

如果所有类的定义都是硬编码的，则可以使其成为类属性而不是方法。

class CB(B):
    cls_definitions = {'C' : 444}

并替换它：

            dct.update(cl.get_definitions())

用这个：

            dct.update(cl.cls_definitions)

为多个级别的祖先继承字典

1 个答案: