何时在 Python 中内联元类的定义？

Question

今天，我在这里发现了Python中元类的令人惊讶的定义，其中包含元类定义有效内联。相关部分是

class Plugin(object):
    class __metaclass__(type):
        def __init__(cls, name, bases, dict):
            type.__init__(name, bases, dict)
            registry.append((name, cls))

何时使用这样的内联定义有意义？

进一步的论点：

一种论点是，使用此技术创建的元类不能在其他地方重用。一个反驳的论点是，使用元类的常见模式是定义元类并在一个类中使用它，然后从中继承。例如，在保守元类中，定义

class DeclarativeMeta(type):
    def __new__(meta, class_name, bases, new_attrs):
        cls = type.__new__(meta, class_name, bases, new_attrs)
        cls.__classinit__.im_func(cls, new_attrs)
        return cls
class Declarative(object):
    __metaclass__ = DeclarativeMeta
    def __classinit__(cls, new_attrs): pass

可以写为

class Declarative(object):  #code not tested!
    class __metaclass__(type):
        def __new__(meta, class_name, bases, new_attrs):
            cls = type.__new__(meta, class_name, bases, new_attrs)
            cls.__classinit__.im_func(cls, new_attrs)
            return cls
    def __classinit__(cls, new_attrs): pass

任何其他考虑因素？

Answer 1

与嵌套类定义的所有其他形式一样，对于多种“生产用途”，嵌套元类可能更加“紧凑和方便”（只要您同意不重用该元类（除非通过继承）），但可能有点不方便调试和自省。

基本上，您将得到一个模块中定义的所有自定义元类，而不是给元类一个正确的顶级名称，它们基于 __module__ 和 彼此无法区分。 __name__ 属性（Python 在需要时使用它来形成其 repr）。考虑一下：

>>> class Mcl(type): pass
... 
>>> class A: __metaclass__ = Mcl
...
>>> class B:
...   class __metaclass__(type): pass
... 
>>> type(A)
<class '__main__.Mcl'>
>>> type(B)
<class '__main__.__metaclass__'>

IOW，如果您想检查“哪种类型是 A 类”（元类是类的类型，请记住），您会得到一个清晰且有用的答案 - 它是主模块中的 Mcl 。但是，如果您想检查“哪种类型是 B 类”，答案并不是那么有用：它说它是 main__metaclass__ > 模块，但这甚至不是真的：

>>> import __main__
>>> __main__.__metaclass__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '__metaclass__'
>>> 

……实际上没有这样的东西；该陈述具有误导性，而且没有多大帮助；-)。

类的 repr 本质上是 '%s.%s' % (c.__module__, c.__name__) —— 一个简单、有用且一致的规则 —— 但在许多情况下，例如 < code>class 语句在模块范围内不是唯一的，或者根本不在模块范围内（而是在函数或类主体内），或者甚至不存在（当然可以在没有 的情况下构建类） class 语句，通过显式调用它们的元类），这可能会有些误导（最好的解决方案是尽可能避免这些特殊情况，除非使用它们可以获得实质性优势）。例如，考虑一下：

>>> class A(object):
...   def foo(self): print('first')
... 
>>> x = A()
>>> class A(object):
...   def foo(self): print('second')
... 
>>> y = A()
>>> x.foo()
first
>>> y.foo()
second
>>> x.__class__
<class '__main__.A'>
>>> y.__class__
<class '__main__.A'>
>>> x.__class__ is y.__class__
False

在同一范围内有两个 class 语句，第二个语句重新绑定名称（此处为 A），但现有实例引用第一个绑定的按对象命名，而不是按名称 - 因此两个类对象都保留，一个只能通过其实例的 type （或 __class__ 属性）访问（如果有的话 - 如果没有） ，第一个对象消失）——这两个类具有相同的名称和模块（因此具有相同的表示形式），但它们是不同的对象。如果需要调试或内省，嵌套在类或函数体内的类，或者通过直接调用元类（包括 type）创建的类，可能会导致类似的混乱。

因此，如果您永远不需要调试或以其他方式反思该代码，则嵌套元类是可以的，并且如果这样做的人理解这种怪癖，则可以忍受（尽管它永远不会像使用漂亮的真实名称那样方便，当然——就像调试用 lambda 编码的函数不可能像调试用 def 编码的函数那么方便一样）。通过与 lambda 与 def 类比，您可以合理地声称匿名的“嵌套”定义对于元类来说是可以的，这些元类是如此简单，如此简单，无需调试或可以想象，反省是必要的。

在Python 3中，“嵌套定义”不起作用——在那里，元类必须作为关键字参数传递给类，如class A(metaclass=Mcl):，所以在正文中定义 __metaclass__ 没有任何效果。我相信这也表明，只有当您确定代码永远不需要移植到 Python 3 时，Python 2 代码中的嵌套元类定义才可能是合适的（因为您使该移植变得更加困难，并且需要为此目的取消元类定义的嵌套）——换句话说，当 Python 3 的某些版本在速度、功能或第三方方面获得巨大的、引人注目的优势时，“一次性”代码在几年内就不会出现了——各方支持，超过 Python 2.7（Python 2 的最后一个版本）。

正如计算的历史向我们展示的那样，您期望被丢弃的代码有一个可爱的习惯，它会让您完全惊讶，并且在大约 20 年后仍然存在（而也许您大约在同一时间编写的代码） “多年来”完全被遗忘了;-)。这似乎肯定会建议避免元类的嵌套定义。