1 个类继承 2 个不同的元类（abcmeta 和用户定义的元）
Posted
技术标签:
【中文标题】1 个类继承 2 个不同的元类（abcmeta 和用户定义的元）【英文标题】：1 class inherits 2 different metaclasses (abcmeta and user defined meta) 【发布时间】：2015-10-01 11:43:01 【问题描述】：我有一个 class1 需要从两个不同的元类继承，即 Meta1 和 abc.ABCMeta
当前实现：
Meta1 的实现：
class Meta1(type):
def __new__(cls, classname, parent, attr):
new_class = type.__new__(cls, classname, parent, attr)
return super(Meta1, cls).__new__(cls, classname, parent, attr)
class1Abstract 的实现
class class1Abstract(object):
__metaclass__ = Meta1
__metaclass__ = abc.ABCMeta
主类的实现
class mainClass(class1Abstract):
# do abstract method stuff
我知道两次实现 2 个不同的元数据是错误的。
我改变了加载metclass的方式（几次尝试），我明白了 TypeError：调用元类库时出错
metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
我的想法用完了......
EDITED 1
我尝试了这个解决方案，它可以工作，但 mainClass 不是 class1Abstract 的实例
print issubclass(mainClass, class1Abstract) # true
print isinstance(mainClass, class1Abstract) # false
class1Abstract的实现
class TestMeta(Meta1):
pass
class AbcMeta(object):
__metaclass__ = abc.ABCMeta
pass
class CombineMeta(AbcMeta, TestMeta):
pass
class class1Abstract(object):
__metaclass__ = CombineMeta
@abc.abstractmethod
def do_shared_stuff(self):
pass
@abc.abstractmethod
def test_method(self):
''' test method '''
mainClass的实现
class mainClass(class1Abstract):
def do_shared_stuff(self):
print issubclass(mainClass, class1Abstract) # True
print isinstance(mainClass, class1Abstract) # False
由于 mainClass 继承自一个抽象类，python 应该抱怨 test_method 没有在 mainClass 中实现。但它并没有抱怨什么，因为 print isinstance(mainClass, class1Abstract) # False
dir(mainClass)
没有
['__abstractmethods__', '_abc_cache', '_abc_negative_cache', '_abc_negative_cache_version', '_abc_registry']
帮助！
EDITED 2
class1Abstract的实现
CombineMeta = type("CombineMeta", (abc.ABCMeta, Meta1), )
class class1Abstract(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def do_shared_stuff(self):
pass
@abc.abstractmethod
def test_method(self):
''' test method '''
mainClass的实现
class mainClass(class1Abstract):
__metaclass__ = CombineMeta
def do_shared_stuff(self):
print issubclass(mainClass, class1Abstract) # True
print isinstance(mainClass, class1Abstract) # False
dir(mainClass) 现在有了 abstractmethod 的魔法方法
['__abstractmethods__', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__metaclass__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_abc_cache', '_abc_negative_cache', '_abc_negative_cache_version', '_abc_registry', 'do_shared_stuff', 'test_method']
但是 python 没有警告 test_method 没有被实例化
帮助！
【问题讨论】：
这只是python 2吗？ 所以你的主要问题是mainClass 没有抱怨抽象方法没有实例化？我相信python没有提供解决这个问题的方法。而不是在类创建时出现错误，而是在对象创建时出现错误，即。 mainClass().
【参考方案1】：
在 Python 中，每个类只能有一个元类，而不是很多。然而，通过混合这些元类做什么，可以实现类似的行为（例如，如果它有多个元类）。
让我们从简单的开始。我们自己的元类，只是给类添加新属性：
class SampleMetaClass(type):
"""Sample metaclass: adds `sample` attribute to the class"""
def __new__(cls, clsname, bases, dct):
dct['sample'] = 'this a sample class attribute'
return super(SampleMetaClass, cls).__new__(cls, clsname, bases, dct)
class MyClass(object):
__metaclass__ = SampleMetaClass
print("SampleMetaClass was mixed in!" if 'sample' in MyClass.__dict__ else "We've had a problem here")
这会打印“SampleMetaClass was mixed in!”，所以我们知道我们的基本元类工作正常。
现在，另一方面，我们想要一个抽象类，最简单的是：
from abc import ABCMeta, abstractmethod
class AbstractClass(object):
__metaclass__ = ABCMeta
@abstractmethod
def implement_me(self):
pass
class IncompleteImplementor(AbstractClass):
pass
class MainClass(AbstractClass):
def implement_me(self):
return "correct implementation in `MainClass`"
try:
IncompleteImplementor()
except TypeError as terr:
print("missing implementation in `IncompleteImplementor`")
MainClass().implement_me()
这会打印“IncompleteImplementor 中缺少的实现”，然后是“MainClass 中的正确实现”。因此，抽象类也可以正常工作。
现在，我们有 2 个简单的实现，我们需要将两个元类的行为混合在一起。这里有多种选择。
选项 1 - 子类化
可以将SampleMetaClass 实现为ABCMeta 的子类——元类也是类，可以继承它们！
class SampleMetaABC(ABCMeta):
"""Same as SampleMetaClass, but also inherits ABCMeta behaviour"""
def __new__(cls, clsname, bases, dct):
dct['sample'] = 'this a sample class attribute'
return super(SampleMetaABC, cls).__new__(cls, clsname, bases, dct)
现在，我们更改AbstractClass 定义中的元类：
class AbstractClass(object):
__metaclass__ = SampleMetaABC
@abstractmethod
def implement_me(self):
pass
# IncompleteImplementor and MainClass implementation is the same, but make sure to redeclare them if you use same interpreter from the previous test
然后再次运行我们的两个测试：
try:
IncompleteImplementor()
except TypeError as terr:
print("missing implementation in `IncompleteImplementor`")
MainClass().implement_me()
print("sample was added!" if 'sample' in IncompleteImplementor.__dict__ else "We've had a problem here")
print("sample was added!" if 'sample' in MainClass.__dict__ else "We've had a problem here")
这仍然会打印出IncompleteImplementor 没有正确实现，MainClass 是，并且现在两者都添加了sample 类级属性。这里要注意的是，元类的Sample 部分也成功应用于IncompleteImplementor（好吧，没有理由不这样做）。
正如预期的那样，isinstance 和 issubclass 仍然可以正常工作：
print(issubclass(MainClass, AbstractClass)) # True, inheriting from AbtractClass
print(isinstance(MainClass, AbstractClass)) # False as expected - AbstractClass is a base class, not a metaclass
print(isinstance(MainClass(), AbstractClass)) # True, now created an instance here
选项 2 - 编写元类
其实问题本身就有这个选项，只需要一个小修复即可。将新的元类声明为几个更简单的元类的组合，以混合它们的行为：
SampleMetaWithAbcMixin = type('SampleMetaWithAbcMixin', (ABCMeta, SampleMetaClass), )
如前所述，更改 AbstractClass 的元类（同样，IncompleteImplementor 和 MainClass 不会更改，但如果在同一个解释器中，则重新声明它们）：
class AbstractClass(object):
__metaclass__ = SampleMetaWithAbcMixin
@abstractmethod
def implement_me(self):
pass
从这里开始，运行相同的测试应该会产生相同的结果：ABCMeta 仍然有效并确保实现了@abstractmethod-s，SampleMetaClass 添加了一个sample 属性。
我个人更喜欢后一种选择，原因与我通常更喜欢组合而不是继承的原因相同：在多个（元）类之间最终需要的组合越多 - 组合就越简单。
有关元类的更多信息
最后，我读过的关于元类的最佳解释是这样的答案： What is a metaclass in Python?
【讨论】：
我不认为这些解决方案在创建类时会检查抽象方法。 嗯，这是一个单独的问题 - 仅在实例化时验证实现的事实是 ABCMeta 的实现方式。否则你需要在类声明上设置某种“钩子”——我不确定这是否存在，但如果我在这里错了，请有人纠正我。如果您真的想强制执行此检查，您可以尝试在声明后创建一个类实例，但这仍然是编码人员的责任。另一方面 - 为什么需要这个？也许还有其他方式可以满足同样的需求？【参考方案2】：默认情况下，python 仅在您尝试实例化类时抱怨类具有抽象方法，而不是在您创建类时。这是因为类的元类仍然是ABCMeta（或其子类型），所以允许有抽象方法。
为了得到你想要的，你需要编写自己的元类，当它发现__abstractmethods__ 不为空时会引发错误。这样，您必须明确说明何时不再允许使用抽象方法。
from abc import ABCMeta, abstractmethod
class YourMeta(type):
def __init__(self, *args, **kwargs):
super(YourMeta, self).__init__(*args, **kwargs)
print "YourMeta.__init__"
def __new__(cls, *args, **kwargs):
newcls = super(YourMeta, cls).__new__(cls, *args, **kwargs)
print "YourMeta.__new__"
return newcls
class ConcreteClassMeta(ABCMeta):
def __init__(self, *args, **kwargs):
super(ConcreteClassMeta, self).__init__(*args, **kwargs)
if self.__abstractmethods__:
raise TypeError(" has not implemented abstract methods ".format(
self.__name__, ", ".join(self.__abstractmethods__)))
class CombinedMeta(ConcreteClassMeta, YourMeta):
pass
class AbstractBase(object):
__metaclass__ = ABCMeta
@abstractmethod
def f(self):
raise NotImplemented
try:
class ConcreteClass(AbstractBase):
__metaclass__ = CombinedMeta
except TypeError as e:
print "Couldn't create class --", e
class ConcreteClass(AbstractBase):
__metaclass__ = CombinedMeta
def f(self):
print "ConcreteClass.f"
assert hasattr(ConcreteClass, "__abstractmethods__")
c = ConcreteClass()
c.f()
哪些输出：
YourMeta.__new__
YourMeta.__init__
Couldn't create class -- ConcreteClass has not implemented abstract methods f
YourMeta.__new__
YourMeta.__init__
ConcreteClass.f
【讨论】：
ConcreteClassMeta 不是多余的吗？ ABCMeta.__init__ 不会做检查吗？即class CombinedMeta(ABCMeta, YourMeta) 不够吗？【参考方案3】：
无需设置两个元类：Meta1 应继承自 abc.ABCMeta。
【讨论】：
【参考方案4】：在您的 EDITED 代码（1 和 2）中，您几乎完成了。唯一错误的是你如何使用isinstance。您想检查一个类实例（在本例中为 self）是否是给定类的实例（class1Abstract）。例如：
class mainClass(class1Abstract):
def do_shared_stuff(self):
print issubclass(mainClass, class1Abstract) # True
print isinstance(self, class1Abstract) # True
【讨论】：
以上是关于1 个类继承 2 个不同的元类（abcmeta 和用户定义的元）的主要内容，如果未能解决你的问题，请参考以下文章