前端之家

  1. 首页
  2. 问答

python：模拟类变量的多重继承

• 问答

我有一个类层次结构，其中某些方法可以使用在类级别定义的属性列表。

假设对于类A我有A.X = [propA1,propA2]，对于子类C我需要C.X = [propA1,propA2,propC]。子类继承自父类的属性，因此使用super()调用编写类方法是有意义的，每个方法都使用其自己类的属性。

但是，这有点麻烦。我可以在基类的单个方法中处理所有属性。因此，为每个子类定义一个包含新属性数组的类变量并手动向下移cls.__mro__来检索所有属性，确实很自然。

我（以下）提出的内容似乎相对透明，但是它是惯用的吗？有没有更典型的编码模式呢？有没有一种方法可以避免装饰所有子类？

class Base(object):
    pass

class InheritClassVariable:
    def __init__(self,var,base):
        self.var = var
        self.base = base
    def __call__(self,cls):
        name = self.var
        uname = '_' + name
        bases = [B for B in cls.__mro__ if issubclass(B,self.base)]
        setattr(cls,uname,getattr(cls,name,[]))
        value = [item for B in bases for item in getattr(B,[])]
        setattr(cls,value)
        return cls

@InheritClassVariable('X',Base)
class A(Base):
    X = ['propA1','propA2']

@InheritClassVariable('X',Base)
class B(Base):
    X = ['propB']

@InheritClassVariable('X',Base)
class C(A):
    X = ['propC']

@InheritClassVariable('X',Base)
class D(C,B,A):
    X = ['propD']

if __name__ == "__main__":
    print(f"D.X = {D.X}")
iCMS 回答：python：模拟类变量的多重继承

一位评论员提到了元类，这是我所不知道的。我查了一下，发现有一个__init_subclass__方法可以避免某些元类的使用。

众所周知，我可以将代码简化为（编辑）：

def InheritConstantArray(varname,value=[]):
    """Return a class making the 'varname' array to be inherited in subclasses"""
    basename = f"InheritConstantArray{varname}"

    def init_subclass(cls):

        # it seems __class__ won't work here.  I still don't understand
        # why.  All I know is eval() is dirty so I do a lookup.
        allbases = cls.mro()
        base = [b for b in allbases if b.__name__ == basename][0]

        # collaborate with other classes using __init_subclass__().
        # if we want sevaral variables to be inherited.
        super(base,cls).__init_subclass__()

        # base._X[cls] will store original cls.X
        uvarname = f'_{varname}' if varname[0] != '_' else f'{varname}_'
        if not hasattr(base,uvarname):
            setattr(base,uvarname,{base: value})
        stored_values = getattr(base,uvarname)
        stored_values[cls] = cls.__dict__.get(varname,[])

        # Then we set cls.X value from base classes
        bases = [b for b in allbases if issubclass(b,base)]
        values = [i for b in bases for i in stored_values.get(b,[])]
        print(cls,base)
        setattr(cls,varname,values)

    dct = {varname: value,'__init_subclass__': init_subclass}
    base = type(basename,(object,),dct)

    return base

class A(InheritConstantArray('X')):
    X = ['A']

class B(A):
    X = ['B']

class C(A):
    X = ['C']

class D(B,C,InheritConstantArray('Y')):
    X = ['D']
    Y = ['d']

class E(D):
    X = ['E']
    Y = ['e']

class F(D):
    X = ['F']
    Y = ['f']

class G(E,F):
    X = ['G']
    Y = ['g']

if __name__ == "__main__":
    print(f"A.X = {A.X}")
    print(f"B.X = {B.X}")
    print(f"C.X = {C.X}")
    print(f"D.X = {D.X} {D.Y}")
    print(f"E.X = {E.X} {E.Y}")
    print(f"F.X = {F.X} {F.Y}")
    print(f"G.X = {G.X} {G.Y}")

尽管如此，我仍然不确定这是否是标准方法。 （是的，在我的实际问题中，具有类变量和多重继承是非常有道理的。）

class-variablesmultiple-inheritance
本文链接：https://www.f2er.com/1891242.html

大家都在问