子类避免父类的元类

Question

假设我有一个第三方库，其中元类需要我实现一些东西。但我想要一个没有的中间“抽象”子类。我该怎么做？

认为这是第三方库所具有的一个非常小的示例：

class ServingMeta(type):
    def __new__(cls, name, bases, classdict):
        if any(isinstance(b, ServingMeta) for b in bases):
            if "name" not in classdict:
                # Actual code fails for a different reason,
                # but the logic is the same.
                raise TypeError(f"Class '{name}' has no 'name' attribute")
        return super().__new__(cls, name, bases, classdict)

class Serving(object, metaclass=ServingMeta):
    def shout_name(self):
        return self.name.upper()

我无法修改上面的代码。这是一个外部依赖项（我不想分叉它）。

代码就是这样使用的：

class Spam(Serving):
    name = "SPAM"

spam = Spam()
print(spam.shout_name())

但是，我碰巧有很多垃圾邮件，我想介绍一个带有常用辅助方法的基类。像这样的：

class Spam(Serving):
    def thrice(self):
        return " ".join([self.shout_name()] * 3)

class LovelySpam(Spam):
    name = "lovely spam"

class WonderfulSpam(Spam):
    name = "wonderful spam"

显然，这不起作用，并且由于预期良好的TypeError: Class 'SpamBase' has no 'name' attribute declared 而失败。第三方库是否会有一个没有元类的 SpamBase 类，我本可以将其子类化 - 但这次没有这样的运气（我已经提到了给库作者带来的不便）。

我可以把它做成一个mixin：

class SpamMixin(object):
    def thrice(self):
        return " ".join([self.shout_name()] * 3)

class LovelySpam(SpamMixin, Serving):
    name = "lovely spam"

class WonderfulSpam(SpamMixin, Serving):
    name = "wonderful spam"

但是，这让我和我的 IDE 有点畏缩，因为到处重复 SpamMixin 很快就会变得很麻烦，而且因为 object 没有 shout_name 属性（而且我不想让分析工具静音） .简而言之，我就是不喜欢这种做法。

我还能做什么？

有没有办法获得Serving 的无元类版本？我想到了这样的事情：

ServingBase = remove_metaclass(Serving)

class Spam(ServingBase, metaclass=ServingMeta):
    ...

但不知道如何实际实现 remove_metaclass 以及在任何可能的情况下（当然，它必须是可行的，需要一些内省，但它可能需要比我能施展更多的奥术魔法）。

也欢迎任何其他建议。基本上，我想让我的代码 DRY（一个基类来统治它们），并让我的 linter/代码分析图标全是绿色的。

Answer 1

mixin 方法是正确的方法。如果您的 IDE “畏缩”，这对该工具有影响 - 只需禁用一些在为 Python 等动态语言编码时显然是不正确的调整的“功能”。

这甚至与动态创建事物无关，它只是多重继承，该语言自始至终都支持这一点。多重继承的主要用途之一就是能够创建您需要的 mixin。

另一个基于继承的解决方法是让你的层次结构更深一层，并在你想出你的 mixin 方法之后引入元类：

class Mixin(object):
    def mimixin(self): ...

class SpamBase(Mixin, metaclass=ServingMeta):
    name = "stub"

或者只是在中间子类中添加 mixin：

class Base(metaclass=Serving Meta):
     name = "stub"
class MixedBase(Mixin, Base):
     name = "stub"
class MyLovingSpam(MixedBase):
     name = "MyLovingSpam"

如果您不想在每个类中都重复使用 mixin=-base 名称，那么您可以这样做。

仅仅为了后期混入而“删除”一个元类太过分了。真的。破碎的。正如@vaultah 在另一个答案中提到的那样，这样做的方法是动态地重新创建类，但是在中间类中这样做是你不应该做的事情。这样做是为了取悦 IDE 是你不应该做两次的事情：搞乱元类已经够难的了。删除语言自然放置的继承/类创建的东西是令人讨厌的（参见这个答案：How to make a class attribute exclusive to the super class）。另一方面，mixin 和多重继承是很自然的。

你还在吗？我告诉过你不要这样做：

现在，关于您的问题 - 与其在中间类中“抑制元类”，不如继承您在那里的元类并更改其行为 - 这样它就不会检查特别标记的约束classes - 创建一个供您使用的属性，例如 _skip_checking

class MyMeta(ServingMeta):
    def __new__(metacls, name, bases, namespace):
         if namespace.get("_skip_checking", False):
              # hardcode call to "type" metaclass:
              del namespace["_skip_checking"]
              cls = type.__new__(metacls, name, bases, namespace)
         else:
              cls = super().__new__(metacls, name, bases, namespace) 
         return cls
     # repeat for __init__ if needed.  


class Base(metaclass=MyMeta):
     _skip_checking = True
     # define mixin methods

class LoveSpam(Base):
    name = "LoveSpam"

Answer 2

实际上没有直接的方法可以从 Python 类中删除元类，因为元类创建了该类。您可以尝试使用不同的元类重新创建该类，该元类没有不需要的行为。例如，您可以使用type（默认元类）。

In [6]: class Serving(metaclass=ServingMeta):
   ...:     def shout_name(self):
   ...:         return self.name.upper()
   ...: 

In [7]: ServingBase = type('ServingBase', Serving.__bases__, dict(vars(Serving)))

基本上这需要__bases__ 元组和Serving 类的命名空间，并使用它们创建一个新类ServingBase。注：这意味着ServingBase 将接收来自Serving 的所有基础和方法/属性，其中一些可能是由ServingMeta 添加的。