协慌网

 登录 贡献 社区

什么是 Python 中的元类？

什么是元类，我们用它们做什么？

答案

类作为对象

在理解元类之前，您需要掌握 Python 中的类。 Python 对于从 Smalltalk 语言借用的类是非常奇怪的。

在大多数语言中，类只是描述如何生成对象的代码片段。在 Python 中也是如此： 

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是类比 Python 更多。类也是对象。

是的，对象。

一旦使用关键字class ，Python 就会执行它并创建一个 OBJECT。指示

>>> class ObjectCreator(object):
...       pass
...

在内存中创建一个名为 “ObjectCreator” 的对象。

这个对象（类）本身能够创建对象（实例），这就是为什么它是一个类 。

但是，它仍然是一个对象，因此：

  • 您可以将其分配给变量
  • 你可以复制它
  • 你可以添加属性
  • 您可以将其作为函数参数传递

例如： 

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

动态创建类

由于类是对象，因此您可以像任何对象一样动态创建它们。

首先，您可以使用类在函数中创建一个class ： 

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

但它不是那么有活力，因为你还是要自己写全班。

由于类是对象，因此它们必须由某些东西生成。

使用class关键字时，Python 会自动创建此对象。但与 Python 中的大多数内容一样，它为您提供了手动执行此操作的方法。

还记得功能type吗？一个很好的旧函数，可以让您知道对象的类型： 

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

嗯， type具有完全不同的能力，它也可以动态创建类。 type可以将类的描述作为参数，并返回一个类。

（我知道，根据您传递给它的参数，相同的函数可以有两个完全不同的用途，这很愚蠢。由于 Python 的向后兼容性，这是一个问题）

type这种方式工作： 

type(name of the class,
     tuple of the parent class (for inheritance, can be empty),
     dictionary containing attributes names and values)

例如： 

>>> class MyShinyClass(object):
...       pass

可以通过以下方式手动创建： 

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

您会注意到我们使用 “MyShinyClass” 作为类的名称，并使用变量来保存类引用。它们可以不同，但没有理由使事情复杂化。

type接受字典以定义类的属性。所以： 

>>> class Foo(object):
...       bar = True

可以翻译成： 

>>> Foo = type('Foo', (), {'bar':True})

并用作普通类： 

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

当然，你可以继承它，所以： 

>>>   class FooChild(Foo):
...         pass

将会： 

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

最后，您需要为您的班级添加方法。只需使用正确的签名定义函数并将其指定为属性即可。 

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

在动态创建类之后，您可以添加更多方法，就像向正常创建的类对象添加方法一样。 

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

您可以看到我们要去的地方：在 Python 中，类是对象，您可以动态地动态创建类。

这就是 Python 在使用关键字class时所做的事情，它通过使用元类来实现。

什么是元类（最后）

元类是创建类的 “东西”。

你定义类来创建对象，对吗？

但我们了解到 Python 类是对象。

好吧，元类是创建这些对象的原因。他们是班级的班级，你可以这样画出来： 

MyClass = MetaClass()
my_object = MyClass()

您已经看到该type允许您执行以下操作： 

MyClass = type('MyClass', (), {})

这是因为函数type实际上是一个元类。 type是 Python 用于在幕后创建所有类的元类。

现在你想知道为什么它是用小写写的，而不是Type ？

嗯，我想这是具有一致性的问题str ，创建的字符串对象类，并int创建 Integer 对象的类。 type只是创建类对象的类。

您可以通过检查__class__属性来查看。

一切，我的意思是一切，都是 Python 中的一个对象。这包括整数，字符串，函数和类。所有这些都是对象。所有这些都是从一个类创建的： 

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

现在，任何__class__的__class__是什么？ 

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此，元类只是创建类对象的东西。

如果您愿意，可以称之为 “班级工厂”。

type是 Python 使用的内置元类，但当然，您可以创建自己的元类。

__metaclass__属性

在 Python 2 中，您可以在编写类时添加__metaclass__属性（请参阅 Python 3 语法的下一节）： 

class Foo(object):
    __metaclass__ = something...
    [...]

如果这样做，Python 将使用元类来创建类Foo 。

小心，这很棘手。

您首先编写class Foo(object) ，但类对象Foo尚未在内存中创建。

Python 将在类定义中查找__metaclass__ 。如果找到它，它将使用它来创建对象类Foo 。如果没有，它将使用type来创建类。

多次阅读。

当你这样做时： 

class Foo(Bar):
    pass

Python 执行以下操作：

Foo是否有__metaclass__属性？

如果是的话，在内存中创建一个类对象（我说一个类对象，留在这里），使用名称Foo ，使用__metaclass__ 。

如果 Python 不能找到__metaclass__ ，它会寻找一个__metaclass__在模块级，并尝试做同样的（但只适用于不继承任何东西，基本上都是老式类类）。

然后，如果它根本找不到任何__metaclass__ ，它将使用Bar （第一个父）自己的元类（可能是默认type ）来创建类对象。

这里要小心，不会继承__metaclass__属性，父类的元类（ Bar.__class__ ）将是。如果Bar使用__metaclass__属性创建了带有type() Bar （而不是type.__new__() ），则子类将不会继承该行为。

现在最大的问题是，你能在__metaclass__中__metaclass__什么？

答案是：可以创建一个类的东西。

什么可以创造一个类？ type ，或子类或使用它的任何东西。

Python 中的元类 3

在 Python 3 中更改了设置元类的语法： 

class Foo(object, metaclass=something):
    ...

即不再使用__metaclass__属性，而是支持基类列表中的关键字参数。

然而，元类的行为基本保持不变 。

在 python 3 中添加到元类的一件事是你也可以将属性作为关键字参数传递给元类，如下所示： 

class Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):
    ...

阅读以下部分，了解 python 如何处理这个问题。

自定义元类

元类的主要目的是在创建类时自动更改类。

您通常对 API 执行此操作，您希望在其中创建与当前上下文匹配的类。

想象一个愚蠢的例子，你决定模块中的所有类都应该用大写字母写出它们的属性。有几种方法可以做到这一点，但一种方法是在模块级别设置__metaclass__ 。

这样，这个模块的所有类都将使用这个元类创建，我们只需要告诉元类将所有属性都转换为大写。

幸运的是， __metaclass__实际上可以是任何可调用的，它不需要是一个正式的类（我知道，名称中带有'class' 的东西不需要是一个类，去图...... 但它很有帮助）。

因此，我们将从一个简单的例子开始，使用一个函数。 

# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      Return a class object, with the list of its attribute turned
      into uppercase.
    """

    # pick up any attribute that doesn't start with '__' and uppercase it
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val

    # let `type` do the class creation
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with "object" though
    # but we can define __metaclass__ here instead to affect only this class
    # and this will work with "object" children
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

现在，让我们完全相同，但使用真正的类来进行元类： 

# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
    # __new__ is the method called before __init__
    # it's the method that creates the object and returns it
    # while __init__ just initializes the object passed as parameter
    # you rarely use __new__, except when you want to control how the object
    # is created.
    # here the created object is the class, and we want to customize it
    # so we override __new__
    # you can do some stuff in __init__ too if you wish
    # some advanced use involves overriding __call__ as well, but we won't
    # see this
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

但这不是真正的 OOP。我们直接调用type ，我们不会覆盖或调用父__new__ 。我们开始做吧： 

class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        # reuse the type.__new__ method
        # this is basic OOP, nothing magic in there
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

你可能已经注意到额外的参数upperattr_metaclass 。它没有什么特别之处： __new__总是接收它定义的类，作为第一个参数。就像你有self的普通方法接收实例作为第一个参数，或者类方法的定义类。

当然，为了清楚起见，我在这里使用的名称很长，但是对于self ，所有的参数都有传统的名称。所以真正的生产元类看起来像这样： 

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

我们可以通过使用super来使它更干净，这将使继承变得更容易（因为是的，你可以拥有元类，继承自元类，继承自类型）： 

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

哦，如果你用关键字参数进行调用，在 python 3 中，如下所示： 

class Foo(object, metaclass=Thing, kwarg1=value1):
    ...

它在元类中转换为使用它： 

class Thing(type):
    def __new__(cls, clsname, bases, dct, kwargs1=default):
        ...

而已。实际上没有关于元类的更多信息。

使用元类的代码复杂性背后的原因不是因为元类，而是因为你通常使用元类来依赖于内省，操纵继承，诸如__dict__变量等来做扭曲的东西。

实际上，元类特别适用于制作黑魔法，因此也很复杂。但就其本身而言，它们很简单：

  • 拦截一个类创建
  • 修改课程
  • 返回修改后的类

为什么要使用元类而不是函数？

由于__metaclass__可以接受任何可调用的，为什么你会使用一个类，因为它显然更复杂？

这样做有几个原因：

  • 目的很明确。当您阅读UpperAttrMetaclass(type) ，您知道将要遵循的内容
  • 你可以使用 OOP。 Metaclass 可以从元类继承，覆盖父方法。元类甚至可以使用元类。
  • 如果您指定了元类，但没有使用元类函数，则类的子类将是其元类的实例。
  • 您可以更好地构建代码。你从不使用元类来处理像上面例子那样简单的事情。它通常用于复杂的事情。能够制作多个方法并将它们分组在一个类中对于使代码更易于阅读非常有用。
  • 你可以挂钩__new__ __init__ ， __init__和__call__ 。这将允许你做不同的东西。即使通常你可以在__new__完成所有__new__ ，但有些人使用__init__更舒服。
  • 这些被称为元类，该死的！它必须意味着什么！

你为什么要使用元类？

现在是个大问题。为什么你会使用一些不起眼的容易出错的功能？

好吧，通常你不会：

元类是更深层次的魔力，99％的用户永远不会担心。如果你想知道你是否需要它们，你就不会（实际需要它们的人肯定知道他们需要它们，并且不需要解释原因）。

Python 大师 Tim Peters

元类的主要用例是创建 API。一个典型的例子是 Django ORM。

它允许您定义如下内容： 

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

但是如果你这样做： 

guy = Person(name='bob', age='35')
print(guy.age)

它不会返回IntegerField对象。它将返回一个int ，甚至可以直接从数据库中获取它。

这是可能的，因为models.Model定义了__metaclass__并且它使用了一些魔法，它将您刚刚使用简单语句定义的Person转换为数据库字段的复杂钩子。

Django 通过公开一个简单的 API 并使用元类，从这个 API 中重新创建代码来完成幕后的实际工作，从而使复杂的外观变得简单。

最后一个字

首先，您知道类是可以创建实例的对象。

事实上，类本身就是实例。元类。 

>>> class Foo(object): pass
>>> id(Foo)
142630324

一切都是 Python 中的一个对象，它们都是类的实例或元类的实例。

除了type 。

type实际上是它自己的元类。这不是你可以在纯 Python 中重现的东西，而是通过在实现级别上作弊来完成的。

其次，元类很复杂。您可能不希望将它们用于非常简单的类更改。您可以使用两种不同的技术更改类：

99％的时间你需要改变课程，你最好使用这些。

但是 98％的情况下，你根本不需要改变课程。

元类是类的类。类定义了类的实例（即对象）的行为，而元类定义了类的行为方式。类是元类的实例。

虽然在 Python 中你可以为元类使用任意的 callables（比如Jerub节目），但更好的方法是让它成为一个真正的类本身。 type是 Python 中常用的元类。 type本身就是一个类，它是它自己的类型。你将无法在 Python 中重新创建纯type东西，但是 Python 会有所作为。要在 Python 中创建自己的元类，你真的只想子type 。

元类最常用作类工厂。当您通过调用类创建对象时，Python 通过调用元类创建一个新类（当它执行'class' 语句时）。结合常规的__init__和__new__方法，元类因此允许您在创建类时执行 “额外的事情”，例如使用某些注册表注册新类或者完全替换其他类。

执行class语句时，Python 首先执行class语句的主体作为正常的代码块。生成的命名空间（dict）保存了将要进行的类的属性。通过在__metaclass__类（如果有）的__metaclass__属性或__metaclass__全局变量中查看要被定义的类的基类（元类被继承）来确定元类。然后使用类的名称，基数和属性调用元类来实例化它。

但是，元类实际上定义了类的类型 ，而不仅仅是它的工厂，所以你可以用它们做更多的事情。例如，您可以在元类上定义常规方法。这些元类方法就像类方法一样，它们可以在没有实例的类上调用，但它们也不像类方法，因为它们不能在类的实例上调用。 type.__subclasses__()是type元类的方法示例。您还可以定义常规的 “魔术” 方法，如__add__ __iter__ ， __getattr__ __add__和__getattr__ ，以实现或更改类的行为方式。

这是比特和碎片的汇总示例： 

def make_hook(f):
    """Decorator to turn 'foo' method into '__foo__'"""
    f.is_hook = 1
    return f

class MyType(type):
    def __new__(mcls, name, bases, attrs):

        if name.startswith('None'):
            return None

        # Go over attributes and see if they should be renamed.
        newattrs = {}
        for attrname, attrvalue in attrs.iteritems():
            if getattr(attrvalue, 'is_hook', 0):
                newattrs['__%s__' % attrname] = attrvalue
            else:
                newattrs[attrname] = attrvalue

        return super(MyType, mcls).__new__(mcls, name, bases, newattrs)

    def __init__(self, name, bases, attrs):
        super(MyType, self).__init__(name, bases, attrs)

        # classregistry.register(self, self.interfaces)
        print "Would register class %s now." % self

    def __add__(self, other):
        class AutoClass(self, other):
            pass
        return AutoClass
        # Alternatively, to autogenerate the classname as well as the class:
        # return type(self.__name__ + other.__name__, (self, other), {})

    def unregister(self):
        # classregistry.unregister(self)
        print "Would unregister class %s now." % self

class MyObject:
    __metaclass__ = MyType


class NoneSample(MyObject):
    pass

# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
    def __init__(self, value):
        self.value = value
    @make_hook
    def add(self, other):
        return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
    pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__

注意，这个答案适用于 Python 2.x，因为它是在 2008 年编写的，元类在 3.x 中略有不同。

元类是使 “阶级” 工作的秘诀。新样式对象的默认元类称为 “类型”。 

class type(object)
  |  type(object) -> the object's type
  |  type(name, bases, dict) -> a new type

元类需要 3 个参数。 ' name '，' bases '和' dict '

这是秘密开始的地方。在此示例类定义中查找 name，bases 和 dict 的来源。 

class ThisIsTheName(Bases, Are, Here):
    All_the_code_here
    def doesIs(create, a):
        dict

让我们定义一个元类，它将演示 ' class： ' 如何调用它。 

def test_metaclass(name, bases, dict):
    print 'The Class Name is', name
    print 'The Class Bases are', bases
    print 'The dict has', len(dict), 'elems, the keys are', dict.keys()

    return "yellow"

class TestName(object, None, int, 1):
    __metaclass__ = test_metaclass
    foo = 1
    def baz(self, arr):
        pass

print 'TestName = ', repr(TestName)

# output => 
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName =  'yellow'

而现在，一个实际意味着什么的例子，这将自动使列表中的变量 “属性” 设置在类上，并设置为 None。 

def init_attributes(name, bases, dict):
    if 'attributes' in dict:
        for attr in dict['attributes']:
            dict[attr] = None

    return type(name, bases, dict)

class Initialised(object):
    __metaclass__ = init_attributes
    attributes = ['foo', 'bar', 'baz']

print 'foo =>', Initialised.foo
# output=>
foo => None

请注意，通过使用元类init_attributes获得的 “初始化” 的神奇行为不会传递给 Initalised 的子类。

这是一个更具体的示例，展示了如何子类化'type' 来创建一个在创建类时执行操作的元类。这非常棘手： 

class MetaSingleton(type):
    instance = None
    def __call__(cls, *args, **kw):
        if cls.instance is None:
            cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
        return cls.instance

 class Foo(object):
     __metaclass__ = MetaSingleton

 a = Foo()
 b = Foo()
 assert a is b