术语元编程是指程序具有了解或操纵自身的潜力。Python支持一种称为metaclasses的类的元编程形式。

元类是一个深奥的OOP概念，几乎隐藏在所有Python代码之后。无论您是否知道，都在使用它们。在大多数情况下，您无需意识到这一点。大多数Python程序员很少（即使有的话）也不必考虑元类。

但是，当需要时，Python提供了并非所有面向对象的语言都支持的功能：您可以深入了解并自定义元类。自定义元类的使用引起了一些争议，正如Python 禅意作者Tim Peters所引用的那样：

元类具有比99％的用户应该担心的更深的魔力。如果您想知道是否需要它们，则不需要（实际上需要它们的人肯定会知道他们需要它们，并且不需要解释原因）。”

— 蒂姆·彼得斯

有一些使用者（Pythonista - 众所周知的Python爱好者）认为永远不要使用自定义元类。这可能有点远，但是很可能不需要自定义元类。如果不是很明显有问题需要解决，那么如果以更简单的方式解决问题，它可能会更干净，更易读。

尽管如此，理解 Python 元类还是值得的，因为通过元类可以更好地理解Python 类的内部。可能有一天会遇到一种情况：只需要一个自定义元类即可以解决问题。

旧式与新式类

在Python领域中，类可以是两个变体之一。尚未确定官方术语，因此将它们非正式地称为旧类和新类。

老式类

对于老式的类，类和类型不是一回事。老式类的实例始终由称为的单个内置类型实现instance。如果obj是老式类的实例，则obj.__class__指定该类，但type(obj)始终为instance。以下示例取自 Python 2.7：

>>> class Foo:
...     pass
...
>>> x = Foo()
>>> x.__class__
<class __main__.Foo at 0x000000000535CC48>
>>> type(x)
<type 'instance'>

新型类

新型类统一了类和类型的概念。如果obj是新型类的实例，type(obj)则与相同obj.__class__：

>>> class Foo:
...     pass
>>> obj = Foo()
>>> obj.__class__
<class '__main__.Foo'>
>>> type(obj)
<class '__main__.Foo'>
>>> obj.__class__ is type(obj)
True

>>> n = 5
>>> d = { 'x' : 1, 'y' : 2 }

>>> class Foo:
...     pass
...
>>> x = Foo()

>>> for obj in (n, d, x):
...     print(type(obj) is obj.__class__)
...
True
True
True

类型type和类别class

在Python 3中，所有类都是新型类。因此，在Python 3中，可以互换地引用对象的类型及其类是合理的。

注意：在Python 2中，默认情况下，类为旧样式。在Python 2.2之前，根本不支持新型类。从Python 2.2开始，可以创建它们，但必须将其显式声明为new-style。

请记住，在Python中，一切都是对象。类也是对象。结果，一个类必须具有一个类型。什么是课程类型？

考虑以下：

>>> class Foo:
...     pass
...
>>> x = Foo()

>>> type(x)
<class '__main__.Foo'>

>>> type(Foo)
<class 'type'>

如您所料，type x是class Foo。但是Foo，类本身的类型是type。通常，任何新式类的类型都是type。

您熟悉的内置类的类型也是type：

>>> for t in int, float, dict, list, tuple:
...     print(type(t))
...
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>

就此而言，类型type也是type如此（是的，确实）：

>>> type(type)
<class 'type'>

type是一个元类，其中的类是实例。就像普通对象是类的实例一样，Python中的任何新式类以及Python 3中的任何类都是type元类的实例。

在上述情况下：

• x是class的实例Foo。
• Foo是type元类的实例。
• type也是type元类的实例，因此它也是自身的实例。

动态定义类

type()当传递一个参数时，内置函数将返回对象的类型。对于新型类，通常与对象的__class__属性相同：

>>> type(3)
<class 'int'>
>>> type(['foo', 'bar', 'baz'])
<class 'list'>
>>> t = (1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>
>>> class Foo:
...     pass
...
>>> type(Foo())
<class '__main__.Foo'>

还可以使用三个参数进行调用type(<name>, <bases>, <dct>)：

• <name>指定类名称。这成为__name__该类的属性。
• <bases>指定从其继承的基类的元组。这成为__bases__该类的属性。
• <dct>指定一个包含类主体定义的名称空间字典。这成为__dict__该类的属性。

type()以这种方式进行调用会创建该type元类的新实例。换句话说，它动态创建一个新类。

在以下每个示例中，最上面的代码段使用来动态定义一个类type()，而下面的代码段则使用该class语句以通常的方式定义该类。在每种情况下，这两个代码段在功能上是等效的。

例子1

在第一个示例中，传递给的<bases>和<dct>参数type()均为空。没有指定任何父类的继承，并且最初在命名空间字典中未放置任何内容。这是最简单的类定义：

>>> Foo = type('Foo', (), {})

>>> x = Foo()
>>> x
<__main__.Foo object at 0x04CFAD50>

>>> class Foo:
...     pass
...
>>> x = Foo()
>>> x
<__main__.Foo object at 0x0370AD50>

例子2

这里<bases>是一个具有单个元素的元组Foo，指定Bar从其继承的父类。属性attr最初放置在名称空间字典中：

>>> Bar = type('Bar', (Foo,), dict(attr=100))

>>> x = Bar()
>>> x.attr
100
>>> x.__class__
<class '__main__.Bar'>
>>> x.__class__.__bases__
(<class '__main__.Foo'>,)

>>> class Bar(Foo):
...     attr = 100
...

>>> x = Bar()
>>> x.attr
100
>>> x.__class__
<class '__main__.Bar'>
>>> x.__class__.__bases__
(<class '__main__.Foo'>,)

例子3

这次，又<bases>是空的。通过<dct>参数将两个对象放入名称空间字典中。第一个是名为的属性attr，第二个是名为的函数attr_val，该函数成为已定义类的方法：

>>> Foo = type(
...     'Foo',
...     (),
...     {
...         'attr': 100,
...         'attr_val': lambda x : x.attr
...     }
... )

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
100

>>> class Foo:
...     attr = 100
...     def attr_val(self):
...         return self.attr
...

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
100

例子4

lambda在Python中只能定义非常简单的函数。在下面的示例中，在外部定义了一个稍微复杂一点的函数，然后attr_val通过名称在名称空间字典中将其分配给f：

>>> def f(obj):
...     print('attr =', obj.attr)
...
>>> Foo = type(
...     'Foo',
...     (),
...     {
...         'attr': 100,
...         'attr_val': f
...     }
... )

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
attr = 100

>>> def f(obj):
...     print('attr =', obj.attr)
...
>>> class Foo:
...     attr = 100
...     attr_val = f
...

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
attr = 100

自定义元类

再次考虑这个陈旧的示例：

>>> class Foo:
...     pass
...
>>> f = Foo()

该表达式Foo()创建class的新实例Foo。解释器遇到时Foo()，将发生以下情况：

• 的父类的__call__()方法Foo被调用。由于Foo是标准的新型类，因此其父类是type元类，因此调用type的__call__()方法。

• 该__call__()方法依次调用以下内容：

  • __new__()
  • __init__()

如果Foo未定义__new__()和__init__()，则默认方法继承自Foo的祖先。但是，如果Foo确实定义了这些方法，则它们会覆盖祖先中的方法，从而在实例化时允许自定义行为Foo。

在下面，定义了一个自定义方法，并将new()其指定为__new__()用于的方法Foo：

>>> def new(cls):
...     x = object.__new__(cls)
...     x.attr = 100
...     return x
...
>>> Foo.__new__ = new

>>> f = Foo()
>>> f.attr
100

>>> g = Foo()
>>> g.attr
100

这会修改类的实例化行为Foo：每次Foo创建实例时，默认情况下都会使用名为的属性对其进行初始化，该属性attr的值为100。（这样的代码通常会出现在__init__()方法中，而通常不会出现在方法中__new__()，这个示例是为演示目的而设计的）

现在，正如已经重申的，类也是对象。假设您要在创建类似的类时，可以以类似的自定义方式完成Foo实例化行为。如果要遵循上述模式，需要再次定义一个自定义方法，并将其分配__new__()为该类Foo是实例的方法。Foo是type元类的实例，因此代码如下所示：

# Spoiler alert:  This doesn't work!
>>> def new(cls):
...     x = type.__new__(cls)
...     x.attr = 100
...     return x
...
>>> type.__new__ = new
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    type.__new__ = new
TypeError: can't set attributes of built-in/extension type 'type'

如您所见，除了不能重新分配元类type的__new__()方法。Python不允许这样做。

这可能也是一样。type是从其派生所有新样式类的元类。无论如何，您真的不应该对此乱搞。但是，如果要自定义类的实例化，那又有什么办法？

一种可能的解决方案是自定义元类。本质上，您不必定义type元类，而可以定义自己的元类，该元类是从派生的type，然后您就可以使用元类。

第一步是定义一个从派生的元类，type如下所示：

>>> class Meta(type):
...     def __new__(cls, name, bases, dct):
...         x = super().__new__(cls, name, bases, dct)
...         x.attr = 100
...         return x
...

定义class Meta(type):声明，指定Meta从type派生。由于type是一个元类，因此也构成Meta了一个元类。

请注意，__new__()已为定义了自定义方法Meta。无法type直接对元类执行此操作。该__new__()方法执行以下操作：

• 由父元类（即type）的代理--super()的__new__()方法创建一个新的类
• 将自定义属性分配attr给类，其值为100
• 返回新创建的类

现在，巫毒教的另一半：定义一个新类Foo，并指定其元类是自定义元类Meta，而不是标准元类type。使用metaclass类定义中的关键字来完成此操作，如下所示：

>>> class Foo(metaclass=Meta):
...     pass
...
>>> Foo.attr
100

瞧！ Foo已经拿到Meta元类的attr自动属性。当然，类似定义的任何其他类也将这样做：

>>> class Bar(metaclass=Meta):
...     pass
...
>>> class Qux(metaclass=Meta):
...     pass
...
>>> Bar.attr, Qux.attr
(100, 100)

与类充当创建对象的模板的方式相同，元类充当创建类的模板。元类有时称为类工厂)。

比较以下两个示例：

对象工厂：

>>> class Foo:
...     def __init__(self):
...         self.attr = 100
...

>>> x = Foo()
>>> x.attr
100

>>> y = Foo()
>>> y.attr
100

>>> z = Foo()
>>> z.attr
100

类工厂：

>>> class Meta(type):
...     def __init__(
...         cls, name, bases, dct
...     ):
...         cls.attr = 100
...
>>> class X(metaclass=Meta):
...     pass
...
>>> X.attr
100

>>> class Y(metaclass=Meta):
...     pass
...
>>> Y.attr
100

>>> class Z(metaclass=Meta):
...     pass
...
>>> Z.attr
100

这真的有必要吗？

就像上面的类工厂示例一样简单，这是元类如何工作的本质。它们允许自定义类如何实例化。

尽管如此，attr在每个新创建的类上赋予自定义属性仍然有很多麻烦。您真的需要一个元类吗？

在 Python 中，至少有几种其他方法可以有效地完成同一件事：

简单继承：

>>> class Base:
...     attr = 100
...

>>> class X(Base):
...     pass
...

>>> class Y(Base):
...     pass
...

>>> class Z(Base):
...     pass
...

>>> X.attr
100
>>> Y.attr
100
>>> Z.attr
100

类装饰器：

>>> def decorator(cls):
...     class NewClass(cls):
...         attr = 100
...     return NewClass
...
>>> @decorator
... class X:
...     pass
...
>>> @decorator
... class Y:
...     pass
...
>>> @decorator
... class Z:
...     pass
...

>>> X.attr
100
>>> Y.attr
100
>>> Z.attr
100

结论

正如蒂姆·彼得斯（Tim Peters）所建议的那样，元类很容易进入“从问题中寻找解决方案”的境界。通常不需要创建自定义元类。如果眼前的问题可以用更简单的方法解决，那就应该这样解决。尽管如此，理解元类还是有好处的，这样您就可以大致理解Python类，并可以识别何时才真正适合使用元类。

🐍Python技巧💌

关于作者：
约翰·斯图兹
奥尔登·桑托斯
丹·巴德
乔安娜·贾布隆斯基

❤️快乐Pythoning！

彩蛋

>>> import this