作为对象的类

在理解元类之前，你需要掌握Python中的课程。Python对类是什么有一个非常奇特的想法，是从Smalltalk语言中借来的。

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

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

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

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

是的，对象。

一旦你使用关键字，Python就会执行它并创建一个对象。指令class

>>> 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>

但它并不是那么动态，因为你仍然需要自己编写整个课程。

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

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

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

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

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

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

type工作方式如下：

type(name, bases, attrs)

哪里：

• 名称：类的名称
• bases：父类的元组（用于继承，可以是空的）
• attrs：包含属性名称和值的字典

例如：

>>> 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', (), {})

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

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

好吧，我想这是与 的一致性问题，创建字符串对象的类和创建整数对象的类。 只是创建类对象的类。strinttype

通过检查属性，您可以看到这一点。__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 中，您可以在编写类时添加属性（有关 Python 3 语法，请参阅下一节）：__metaclass__

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

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

小心，这很棘手。

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

Python将在类定义中寻找。如果找到它，它将使用它来创建对象类 。如果没有，它将用于创建类。__metaclass__Footype

读了几遍。

当您执行以下操作时：

class Foo(Bar):
    pass

Python执行以下操作：

中是否有属性？__metaclass__Foo

如果是，请在内存中创建一个类对象（我说的是类对象，请留在这里）。使用.Foo__metaclass__

如果Python找不到，它将在MODULE级别寻找一个，并尝试做同样的事情（但仅适用于不继承任何东西的类，基本上是旧式类）。__metaclass____metaclass__

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

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

现在最大的问题是，你能放什么？__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__

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

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

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

# 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_attrs):
    """
      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_attrs = {
        attr if attr.startswith("__") else attr.upper(): v
        for attr, v in future_class_attrs.items()
    }

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

__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'

让我们检查一下：

>>> hasattr(Foo, 'bar')
False
>>> hasattr(Foo, 'BAR')
True
>>> Foo.BAR
'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_attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in future_class_attrs.items()
        }
        return type(future_class_name, future_class_parents, uppercase_attrs)

让我们重写上面的内容，但是现在我们知道它们的含义，因此可以使用更短，更现实的变量名称：

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type(clsname, bases, uppercase_attrs)

您可能已经注意到了 额外的参数 。它没有什么特别之处：始终接收定义它的类，作为第一个参数。就像普通方法一样，这些方法将实例作为第一个参数接收，或者用于类方法的定义类。cls__new__self

但这不是正确的OOP。我们直接呼叫，我们不会覆盖或调用父母的.让我们这样做：type__new__

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type.__new__(cls, clsname, bases, uppercase_attrs)

我们可以通过使用 使它更加干净，这将简化继承（因为是的，你可以有元类，从元类继承，从类型继承）：super

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return super(UpperAttrMetaclass, cls).__new__(
            cls, clsname, bases, uppercase_attrs)

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

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

它在元类中转换为此函数以使用它：

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

就是这样。元类真的没什么大不了的。

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

事实上，元类对于做黑魔法特别有用，因此是复杂的东西。但就其本身而言，它们很简单：

• 截获类创建
• 修改类
• 返回修改后的类

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

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

这样做有几个原因：

• 意图很明确。当你阅读时，你知道接下来会发生什么UpperAttrMetaclass(type)
• 您可以使用 OOP。元类可以从元类继承，覆盖父方法。元类甚至可以使用元类。
• 如果指定了元类类，则类的子类将是其元类的实例，但不是使用元类函数的。
• 您可以更好地构建代码。你永远不会把元类用于像上面的例子这样微不足道的事情。它通常用于复杂的事情。能够创建多个方法并将它们分组到一个类中对于使代码更易于阅读非常有用。
• 您可以挂接 和 。这将允许你做不同的事情，即使通常你可以做所有的事情，有些人只是更舒服地使用。__new____init____call____new____init__
• 这些被称为元类，该死的！它一定意味着什么！

为什么要使用元类？

现在是一个大问题。为什么要使用一些容易出错的晦涩功能？

好吧，通常你不会：

元类是更深层次的魔力，99%的用户永远不应该担心它。如果你想知道你是否需要它们，你不需要（真正需要它们的人肯定地知道他们需要它们，并且不需要解释为什么）。

Python大师蒂姆·彼得斯

元类的主要用例是创建 API。一个典型的例子是Django ORM。它允许您定义如下内容：

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

但是，如果您这样做：

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

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

这是可能的，因为它定义了一些魔术，它将把你刚刚用简单语句定义的你变成一个复杂的数据库字段钩子。models.Model__metaclass__Person

Django通过公开一个简单的API并使用元类，从这个API重新创建代码来做真正的工作，使复杂的东西看起来很简单。

最后一句话

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

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

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

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

除了 .type

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

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

• 猴子修补
• 类装饰器

99%的时间你需要改变类，你最好使用这些。

但98%的情况下，你根本不需要改变类。

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

虽然在Python中，你可以对元类使用任意可调用（如Jerub所示），但更好的方法是让它成为一个实际的类本身。 是Python中常用的元类。 本身就是一个类，它是它自己的类型。你将无法纯粹在Python中重新创建类似的东西，但是Python有点作弊。要在Python中创建自己的元类，您实际上只想子类。typetypetypetype

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

执行语句时，Python 首先将语句的正文作为普通代码块执行。生成的命名空间（字典）保存要成为的类的属性。元类是通过查看要将来的类的基类（元类被继承）、准类的属性（如果有）或全局变量来确定的。然后使用类的名称，基和属性调用元类以实例化它。classclass__metaclass____metaclass__

但是，元类实际上定义了类的类型，而不仅仅是它的工厂，因此您可以使用它们做更多的事情。例如，您可以在元类上定义普通方法。这些元类方法类似于类方法，因为它们可以在没有实例的情况下在类上调用，但它们也不像类方法，因为它们不能在类的实例上调用。 是元类上方法的示例。您还可以定义正常的“magic”方法，如 、 和 ，以实现或更改类的行为方式。type.__subclasses__()type__add____iter____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__