摘要

目前，定制类创建需要使用自定义元类。这个自定义元类随后在类的整个生命周期中持续存在，从而产生虚假元类冲突的可能性。

本PEP提议通过在类头中添加一个新的 namespace 参数，以及在类体中添加一个新的 __autodecorate__ 钩子来支持各种定制场景。

新的机制应该比实现自定义元类更容易理解和使用，从而为理解Python元类机制的全部功能提供一个更温和的入门。

PEP 撤回

此提案已被撤回，取而代之的是Martin Teichmann在 PEP 487 中的提案，该提案通过一个更简单、更易于使用的 __init_subclass__ 钩子实现了相同的目标，该钩子不会为定义钩子的基类调用。

背景

对于一个已经创建的类 cls，术语“元类”有一个明确的含义：它是 type(cls) 的值。

在类创建过程中，它有另一个含义：它也用于指代可能作为类定义一部分提供的元类提示。虽然在许多情况下，这两个含义最终指代同一个对象，但在两种情况下并非如此

• 如果元类提示指代 type 的实例，那么它将被视为候选元类，以及正在定义的类的所有父类的元类。如果在候选元类中找到更合适的元类，那么它将被用来代替元类提示中给出的元类。
• 否则，显式元类提示被假定为工厂函数，并被直接调用以创建类对象。在这种情况下，最终的元类将由工厂函数定义确定。在典型情况下（工厂函数只调用 type，或者在Python 3.3或更高版本中，调用 types.new_class），实际的元类然后根据父类确定。

值得注意的是，只有实际的元类被继承——用作元类钩子的工厂函数只看到当前正在定义的类，并且不会为任何子类调用。

在 Python 3 中，元类提示是使用类头中的 metaclass=Meta 关键字语法提供的。这允许元类上的 __prepare__ 方法用于创建在执行类体时使用的 locals() 命名空间（例如，指定使用 collections.OrderedDict 而不是普通的 dict）。

在 Python 2 中，没有 __prepare__ 方法（该 API 是由 PEP 3115 为 Python 3 添加的）。相反，类体可以设置 __metaclass__ 属性，类创建过程将从类命名空间中提取该值作为元类提示。有 已发布的代码 利用了此功能。

Python 3 的另一个新特性是 super() 内置函数的零参数形式，由 PEP 3135 引入。此特性使用对正在定义的类的隐式 __class__ 引用来取代 Python 2 中所需的“按名称”引用。就像在 Python 2 元类执行期间调用的代码不能调用通过名称引用类的方法一样（因为该名称尚未在包含作用域中绑定），同样，Python 3 元类也不能调用依赖于隐式 __class__ 引用的方法（因为它在元类将控制权返回给类创建机制之前不会被填充）。

最后，当一个类使用自定义元类时，它可能会给多重继承带来额外的挑战，因为一个新类不能继承自具有不相关元类的父类。这意味着不可能向一个已经发布的类添加一个元类：这种添加是向后不兼容的更改，因为存在元类冲突的风险。

提案

本PEP提议在Python 3.4中添加一个新的定制类创建机制，该机制应满足以下标准：

1. 与类继承结构（包括混入和多重继承）良好集成
2. 与 PEP 3135 引入的隐式 __class__ 引用和零参数 super() 语法良好集成
3. 可以在不显著增加引入向后兼容性问题的风险的情况下，添加到现有基类中
4. 恢复类命名空间对类创建过程产生影响的能力（超出填充命名空间本身），但可能没有 Python 2 风格 __metaclass__ 钩子的全部灵活性

实现此目标的一种机制是添加一个新的隐式类装饰钩子，直接模仿现有的显式类装饰器，但定义在类体或父类中，而不是作为类定义头的一部分。

具体来说，提议类定义能够提供一个类初始化钩子，如下所示

class Example:
    def __autodecorate__(cls):
        # This is invoked after the class is created, but before any
        # explicit decorators are called
        # The usual super() mechanisms are used to correctly support
        # multiple inheritance. The class decorator style signature helps
        # ensure that invoking the parent class is as simple as possible.
        cls = super().__autodecorate__()
        return cls

为了简化协作多重继承的情况，object 将获得一个钩子的默认实现，该实现返回未修改的类

class object:
    def __autodecorate__(cls):
        return cls

如果元类希望出于某种原因阻止隐式类装饰，则必须安排 cls.__autodecorate__ 触发 AttributeError。

如果存在于创建的对象上，这个新的钩子将由类创建机制在 __class__ 引用初始化之后调用。对于 types.new_class()，它将作为返回创建的类对象之前的最后一步被调用。__autodecorate__ 在类创建时（在钩子被调用之前）隐式转换为类方法。

请注意，当调用 __autodecorate__ 时，类的名称尚未绑定到新的类对象。因此，super() 的两参数形式不能用于调用方法（例如，super(Example, cls) 在上面的示例中将不起作用）。然而，super() 的零参数形式按预期工作，因为 __class__ 引用已经初始化。

这个通用提案并非新想法（它首次被建议纳入语言定义 十多年前，并且Zope的ExtensionClass长期支持类似机制 Zope’s ExtensionClass），但近年来情况发生了足够大的变化，值得重新考虑将其作为原生语言特性纳入。

此外，在PEP 3115中引入的元类 __prepare__ 方法允许进一步增强，这在Python 2中是不可能的：本PEP还提议更新 type.__prepare__ 以接受工厂函数作为 namespace 仅关键字参数。如果存在，作为 namespace 参数提供的值将被无参数调用，以创建 type.__prepare__ 的结果，而不是使用新创建的字典实例。例如，以下代码将使用有序字典作为类命名空间

class OrderedExample(namespace=collections.OrderedDict):
    def __autodecorate__(cls):
        # cls.__dict__ is still a read-only proxy to the class namespace,
        # but the underlying storage is an OrderedDict instance

主要优点

设计说明

class Example:
    def __autodecorate__(cls):
        cls = super().__autodecorate__()
        # Don't process the base class
        if cls is __class__:
            return
        # Process subclasses here
        ...

class BuildDict:
    def __autodecorate__(cls):
        cls = super().__autodecorate__()
        # Don't process the base class
        if cls is __class__:
            return
        # Convert subclasses to ordinary dictionaries
        return cls.__dict__.copy()

开放问题

使用类的新方式

类头中新的 namespace 关键字为控制类初始化方式提供了许多有趣的选项，包括 Javascript 和 Ruby 对象模型的某些方面。

下面所有的例子实际上都可以通过使用自定义元类实现

class CustomNamespace(type):
    @classmethod
    def __prepare__(meta, name, bases, *, namespace=None, **kwds):
        parent_namespace = super().__prepare__(name, bases, **kwds)
        return namespace() if namespace is not None else parent_namespace
    def __new__(meta, name, bases, ns, *, namespace=None, **kwds):
        return super().__new__(meta, name, bases, ns, **kwds)
    def __init__(cls, name, bases, ns, *, namespace=None, **kwds):
        return super().__init__(name, bases, ns, **kwds)

直接在 type.__prepare__ 中实现新关键字的优点是，唯一持久的影响是类属性底层存储的变化。类的元类保持不变，消除了通常与这类定制相关的许多缺点。

class OrderedClass(namespace=collections.OrderedDict):
    a = 1
    b = 2
    c = 3

seed_data = dict(a=1, b=2, c=3)
class PrepopulatedClass(namespace=seed_data.copy):
    pass

class NewClass(namespace=Prototype.__dict__.copy):
    pass

from collections import MutableMapping

# The MutableMapping + dict combination should give something that
# generally behaves correctly as a mapping, while still being accepted
# as a class namespace
class ClassNamespace(MutableMapping, dict):
    def __init__(self, cls):
        self._cls = cls
    def __len__(self):
        return len(dir(self._cls))
    def __iter__(self):
        for attr in dir(self._cls):
            yield attr
    def __contains__(self, attr):
        return hasattr(self._cls, attr)
    def __getitem__(self, attr):
        return getattr(self._cls, attr)
    def __setitem__(self, attr, value):
        setattr(self._cls, attr, value)
    def __delitem__(self, attr):
        delattr(self._cls, attr)

def extend(cls):
    return lambda: ClassNamespace(cls)

class Example:
    pass

class ExtendedExample(namespace=extend(Example)):
    a = 1
    b = 2
    c = 3

>>> Example.a, Example.b, Example.c
(1, 2, 3)

被拒绝的设计选项

参考实现

已向 问题追踪器 发布了 __autodecorate__ 的参考实现。它使用原始的 __init_class__ 命名。它尚不允许隐式装饰器用不同的对象替换类，并且未实现 type.__prepare__ 的建议 namespace 参数。

待办事项

• 解决 https://mail.python.org/pipermail/python-dev/2013-February/123970.html 中的5个要点

版权

本文档已置于公共领域。