本文主要向大家介绍了深入理解Python语言，什么是元类（metaclass），通过具体的内容向大家展示，希望对大家学习Python语言有所帮助。

<__main__.objectcreator object="" at="" 0x8974f2c="">但是类在Python中不仅仅是这样，类也是对象。当你使用关键字class时，Python执行它并创建了一个对象。这个语句>>> class ObjectCreator(object):...       pass...在内存中创建了一个名为“ObjectCreator”的对象。这个对象（这个类）本身是能够创建对象（实例）的，这也是称之为类的原因。但是，它仍然是一个对象，因此：你可以把它赋值给一个变量；你能复制它；你能给它添加属性；你能将它作为一个函数参数传递。例如：>>> print(ObjectCreator) # you can print a class because it's an object

>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter

>>> 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="">2）动态地创建类因为类是对象，你能动态地创建它们，就像其他对象一样。首先，你可以在一个函数中使用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

>>> print(MyClass()) # you can create an object from this class
<__main__.foo object="" at="" 0x89c6d4c="">但是这不够动态，因为你仍然需要去完整地定义这个类。因为类是对象，它们肯定能用其他方式生成。当你使用class这个关键字时，Python自动创建了这个对象。但是正如在Python中做的大部分事情一样，Python同样提供了手动触发的方式。还记得函数type吗？一个古老而又有用的函数，能够让你知道一个对象的类型是什么。>>> print(type(1))

>>> print(type("1"))

>>> print(type(ObjectCreator))

>>> print(type(ObjectCreator()))
type还有一个完全不同的功能，它也动态地创建对象。type能够接受一个类的描述作为参数，然后返回一个类。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)

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

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

>>> 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中，类也是对象，而且你能动态地创建一个类。这就是当你使用class这个关键字时Python所做的，Python使用元类来完成这项工作。3）什么是元类元类就是我们创建对象的东东。你定义一个类是为了创建对象，对吗？但是刚才我们了解到了Python类也是对象。元类是创建这些对象的东东。他们是类的类，你可以用这种方式去描述它。MyClass = MetaClass()
my_object = MyClass()我们已经看到了type能让你像这样做。MyClass = type('MyClass', (), {})这是因为type这个函数事实上是一个元类。type是Python在背后用来创建所有类的元类。现在你可能想知道，为什么type首字母要小写，而不是写成Type我猜，这与语言一致性有关，例如str是创建字符串对象的类，int是创建整数对象d的类，type就是用来创建类对象的类。你可以检查__class__属性看到。在Python中一切皆对象。包括整数、字符串、函数和类。它们都是对象，而且它们都是由类产生的。>>> age = 35
>>> age.__class__

>>> name = 'bob'
>>> name.__class__

>>> def foo(): pass
>>> foo.__class__

>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
现在，如何__class__的__class__是什么呢？>>> age.__class__.__class__
>>> name.__class__.__class__
>>> foo.__class__.__class__
>>> b.__class__.__class__
因此，元类就是创建类对象的东东。如果你愿意，可以称它为"类工厂"。type是Python使用的内置的元类，当然，你也能创建自己的元类。4）__metaclass__ 属性当你定义一个类时，可以添加一个__metaclass__属性。class Foo(object):
    __metaclass__ = something...
    [...]如果你这样做的话，Python将使用这个元类去创建类Foo小心，这有陷阱。你首先写了class Foo(object)，但是这个类对象Foo在内存中并没有被创建。Python将在类定义中寻找__metaclass__如果Python发现了它，Python将使用它去创建类对象Foo，如果没有，Python将使用type去创建这个类。重温几次。当你定义：class Foo(Bar):
    passPython将做以下事情：
在Foo中有__metaclass__属性吗？如果有，就使用__mataclass__中定义的东东在内存中创建类对象，类名为Foo。如果Python没有找到__metaclass__属性，它将在MODULE层寻找一个__metaclass__，去做相同的事情（对于类，不继承任何东西，基础的老式类）。然后如果Python不能找到任何的__metaclass__，它将使用Bar（第一个父类）自己的元类（可能是type）去创建类对象。这里小心__metaclass__属性将不会被继承，父类的元类（Bar.__class__）会被继承。如果Bar使用了一个用type（不是type.__new__()）创建Bar的__metaclass__属性，那么它的子类将会继承这个行为。现在最大的问题是，你能在__metaclass__中定义什么？答案就是，能够创建类的东东。什么能创建类呢？type，或者它的子类，或者用了它的任何东西。5）自定义元类元类的主要目的是为了创建时自动地改变类。经常为了API这么做，API中需要创建类去匹配当前的上下文。想象一个非常蠢的例子，你决定你的模块中的所有类它们的属性应该大写。有好几种方式可以完成这件事，其中一种方式就是在模块层设置__metaclass__。使用这种方式，模块内所有的类都会使用这个元类创建，而且我们必须告诉元类要将所有的属性转为大写。幸运的是，__metaclass__确实是可调用的，它不需要是一个正式的类（在名字中带有类，但是不必要是一个类，区分一下，但是这很有用）。接下来我们使用函数写个简单的例子。# coding=utf-8# 适用于python2# 元类将自动获取到相同的你经常传给`type`的参数。# 即参数列表与`type`的一致。def upper_attr(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    # 使用type创建类
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # 这将影响这个模块内的所有类。class Foo(): # 虽然全局的 __metaclass__ 对 “object”无效
    # 但是我们可以在这里定义 __metaclass__ 而不是仅仅影响这个类。
    # 这将影响“object”的children
    bar = 'bip'print(hasattr(Foo, 'bar'))# Out: Falseprint(hasattr(Foo, 'BAR'))# Out: Truef = Foo()
print(f.BAR)# Out: 'bip'现在，我们用一个真实的类作为元类去做相同的事情。# coding=utf-8# 记住`type`事实上是一个类似于`str`和`int`的类# 所以你能继承它class UpperAttrMetaclass(type):
    # __new__ 方法在 __init__ 前执行，这个方法创建对象并返回。
    # __init__方法仅仅初始化作为参数传入的对象。
    # 你很少使用__new__方法，除非你想控制类是如何创建的。
    # 这里创建的对象是一个类，我们想自定义它，因此需要覆盖 __new__。
    # 你也能在__init__中做一些事情，如果愿意的话。
    # 一些高级用法还包括覆盖__call__方法，这里不使用。
    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__，改一下：# coding=utf-8class 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        # 重用了type.__new__方法，这种写法是OOP的
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)你可能注意到额外的参数upperattr_metaclass，这没什么特别的：__new__方法总是接受定义的类作为第一个参数，就像普通方法接受实例作为第一个参数传入self，类方法传入定义类一样。当然，为了可读性，我在这里使用的名字太长了。但是就如self一样，所有的参数都有约定俗成的名字，因此一个真实的正式的metaclass应该像这样写：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)以上就是全部了，关于元类已经没有什么内容了。使用元类的代码复杂的原因并不在于元类本身，而是因为你经常使用元类去做一些扭曲的事情，操纵继承，遍历属性（vars）例如__dict__等等。事实上，元类在做一些黑科技时非常有用，因此往往是一些复杂的东西。但是就元类本身而言，是简单的。拦截类的创建。修改类。返回修改后的类。6）为什么使用元类时用类而不用函数？因为__metaclass__能够接受任何可调用的东西，为什么要去使用明显更为复杂的类呢？这么做有几个原因：目的更明确，当你阅读UpperAttrMetaclass(type)，你知道接下来会发生什么。更OOP。元类能够继承元类，覆盖父类的方法。元类甚至能使用元类。一个类的子类可以是它的元类的实例如果你指定了一个元类类（metaclass-class），而不是一个元类函数（metaclass-function）。能更好地组织代码。你从来没有像上面的例子这样试验性地使用元类。元类经常用于一些复杂场景。为了代码可读性，将好几个方法组织在一个类中的能力是非常重要的。你能覆盖__new__，__init__和__call__，这些方法将允许你做不同的事情。即时即经常只需要修改__new__，一些人觉得使用__init__更舒服。它们被称为元类，实际就应该和它的名称一致。7）为什么使用元类现在最大的问题，为什么要使用这么晦涩的容易出错的特性？通常不要用：元类是深魔法，99%的用户都不需要关心它。如果你在想是否需要它们，就不要用（需要元类的人确切地知道需要它，无需解释）。Python Guru 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)它将不会返回一个IntegerFiled对象，它将返回一个int，而且甚至直接传给数据库。这是可能的，因为models.Model定义了__metaclass__而且进行了一些特殊处理，将你刚刚简单几句话定义的Person转变为数据库字段的复杂钩子。Django通过使用元类暴露简单的API，让一些复杂的事情看上去简单，通过这些API背后重新创建代码去做真实的事情。8）最后一点首先，你知道类是能够创建实例的对象。事实上，类本身就是对象，元类也是。>>> class Foo(object): pass>>> id(Foo)142630324Python中一切皆对象，而且他们也是类的实例或类的实例。除了typetype确实是自己的元类，这只用Python是产生不了的，这是在实现层面做的。第二，元类是复杂的。你可能想去使用他们去做简单的类修改。你能使用2种其他的技术去做这件事。猴子补丁（monkey patching）类装饰器（class decorators）类修改99%的场景适合以上方式。但是98%的场景，根本不需要去修改类。9）Python3补充Python3和Python2中元类使用有区别。以下是使用元类实现追踪类定义顺序的例子。class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1class MyType(object):              # Python 2
    __metaclass__ = MyMetaclass MyType(metaclass=MyMeta):    # Python 3
    passPython3中元类有2个关键的方法。__prepare____new____prepare__让你提供一个自定义的字典（例如OrderedDict）作为元类创建时的命名空间。无论选择什么命名空间，都必须返回一个实例。如果没有实现__prepare__，将会使用一个普通的dict。class Meta(type):

    def __prepare__(metaclass, cls, bases):
        return dict()    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

本文由职坐标整理并发布，希望对同学们学习Python有所帮助，更多内容请关注职坐标编程语言Python频道！