来自元类工厂的多重继承

Question

我希望 SuperClass12 继承自 SuperClass1 和 SuperClass2：

def getClass1(): 
    class MyMetaClass1(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta1"
            return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
    return MyMetaClass1

def getClass2(): 
    class MyMetaClass2(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta2"
            return super(MyMetaClass2, cls).__new__(cls, name, bases, dct)
    return MyMetaClass2    

class SuperClass1():
    __metaclass__ = getClass1()
    def fun1(self):
        pass

class SuperClass2():
    __metaclass__ = getClass2()
    def fun2(self):
        pass

class MyClass1(SuperClass1):
    Attr = "MC1"

class MyClass2(SuperClass2):
    Attr = "MC2"

def getClass12(): 
    class myMultiMeta(getClass1(),getClass2()):
        pass
    return myMultiMeta

class SuperClass12(SuperClass1,SuperClass2):
#class SuperClass12(): gives no errors in class construction but then 
#fun1() and fun2() are not members of SuperClass12. 
    __metaclass__ = getClass12()

class MyClass12(SuperClass12):
    Attr = "MC12"

Instance = MyClass12()
Instance.fun1()
Instance.fun2()

遗憾的是我遇到了这个错误：

TypeError：调用元类基元类冲突时出错：派生类的元类必须是其所有基类的元类的（非严格）子类

但我无法理解为什么，因为元类 myMultiMeta我的派生类 SuperClass12 确实是其所有基类的元类 (MyMetaClass1,MyMetaClass2) 的子类（SuperClass1，SUperClass2）。

Answer 1

正如 Michael Merickel 所指出的，getClass() 函数需要在每次调用时返回相同的对象，继承才能正常工作。仅仅相同的类是不够好的。这里有一种方法可以做到这一点，即滥用一个类，使其表现得像您的 getClass() 函数。由于类定义仅执行一次，因此返回时 MyMetaClass1 始终是相同的对象。

class getClass1(object):
    class MyMetaClass1(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta1"
            return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
    class __metaclass__(type):
        def __call__(cls):
            return cls.MyMetaClass1

您也可以这样做，使用真实函数并滥用可变默认参数来缓存类实例：

def getClass1(cls=[]):
    if not cls:
        class MyMetaClass1(type):
            def __new__(cls, name, bases, dct):
                print dct.get("Attr","")+"Meta1"
                return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
        cls.append(MyMetaClass1)
    return cls[0]

您会注意到这里反复出现的主题：滥用 Python 功能。 :-) 这通常表明您正在做的事情也许可以通过其他方式做得更好。例如，为什么要使用工厂，而不是仅以正常方式定义类？我已经看到类工厂有一些用处，但我认为我从未在野外见过元类工厂。

Answer 2

请记住，getClass1 和 getClass2 返回元类的新实例。因此，当您设置 __metaclass__ = getClass1() 时，这是一个与 myMultiMeta 继承的元类不同的元类。

Answer 3

这是你想要的吗？

class MyMetaClass1(type):
    def __new__(cls, name, bases, dct):
        print dct.get("Attr","")+"Meta1"
        return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)

class MyMetaClass2(type):
    def __new__(cls, name, bases, dct):
        print dct.get("Attr","")+"Meta2"
        return super(MyMetaClass2, cls).__new__(cls, name, bases, dct)

class SuperClass1():
    __metaclass__ = MyMetaClass1
    def fun1(self):
        pass

class SuperClass2():
    __metaclass__ = MyMetaClass2
    def fun2(self):
        pass

class MyClass1(SuperClass1):
    Attr = "MC1"

class MyClass2(SuperClass2):
    Attr = "MC2"

class MyMultiMeta(MyMetaClass1, MyMetaClass2):
    pass

class SuperClass12(SuperClass1, SuperClass2):
#class SuperClass12(): gives no errors in class construction but then 
#fun1() and fun2() are not members of SuperClass12. 
    __metaclass__ = MyMultiMeta

class MyClass12(SuperClass12):
    Attr = "MC12"

Instance = MyClass12()
Instance.fun1()
Instance.fun2()

跑步：

vic@ubuntu:~/Desktop$ python test.py 
Meta1
Meta2
MC1Meta1
MC2Meta2
Meta1
Meta2
MC12Meta1
MC12Meta2
vic@ubuntu:~/Desktop$ 

Answer 4

我感谢谁通过给出一些答案来帮助我：

def getClass12(): 
     class myMultiMeta(SuperClass1.__metaclass__,SuperClass2.__metaclass__):
         pass
     return myMultiMeta
 class SuperClass12(SuperClass1,SuperClass2):
     __metaclass__ = getClass12()

这是一个不错的解决方案！