Metaclasses are deeper magic that 99% of users should never worry about. If you wonder whether you need them, you don’t (the people who actually need them know with certainty that they need them, and don’t need an explanation about why). —— Python界的领袖 Tim Peters

Zen of Python的 作者Tim Peters大神说99%的Python用户根本不需要为元类操心。虽然大神这么说了，但我认为还是有必要了解下这个Python的黑魔法，至少要知道它是什么东东。

关于元类的介绍网上已经有很多资料了，目前为止我认为介绍的最好的是《深刻理解Python中的元类(metaclass)》这篇从Stackoverflow翻译过来的资料。
但是还有些瑕疵，比如__metaclass__如果定义在模块顶层，那么只有对旧式类才会起作用，而它没有对这点进行说明。所以如果可以话，请直接阅读英文原文

读完上面的文档之后，我对于元类有了个大概的了解，但是其中的一些细节还是需要进一步实践验证，下面我就通过代码来展示一些我对元类细节的理解。
注意：因为本人是使用Python 2.7为主，所以下文除了标明了Python 3.x的部分，其余都是基于Python 2.7的

元类的本质

元类就是用来创建类的“东西”，这句话必须要牢牢记住，元类是用来创建类的。我们知道类可以用来创建实例，而元类它的“实例”就是另一个类。

MyClass = MetaClass()
MyObject = MyClass()

__metaclass__

Python 2.7通过__metaclass__属性来实现元类功能

def create_class(name, bases, attr): #注意必须有三个参数
    return type(name, bases, attr)

class MyClass(object):
    __metaclass__ = create_class

class MetaClass(type):
    pass

__metaclass__ = MetaClass
class MyClass1:
    pass

class MyClass2(object):
    __metaclass__ = MetaClass

在Python 2.7版本里__metaclass__属性既可以是一个函数，也可以是一个类，只要这个东西在执行之后能返回一个类就行。
另外注意在模块定义的__metaclass__属性只对旧式类起作用

解释器在生成类对象的时候会首选在当前类定义中查找是否有__metaclass__属性，如果有则按照当前类定义的__metaclass__属性生成类，否则继续去父类中查找__metaclass__属性，如果所有父类中都没有找到__metaclass__属性，则继续在模块中查找，如果还是没有找到，则按照类定义生成类对象。(对于新式类，没有查找模块__metaclass__属性这步)
所以__metaclass__属性对解释器而言就是一个生成类对象的Hook，它会拦截解释器正常生成类对象的流程。

Python 3.x取消了__metaclass__属性，改为

class MyClass3(metaclass=MetaClass): # MetaClass也可以是个函数
    pass

这种方式来实现元类。

元类构造过程

class MetaClass(type):
    
    def __init__(cls, name, bases, attr):
        print "MetaClass __init__:", cls.__name__
        
    def __new__(cls, name, bases, attr):
        print "MetaClass __new__:", cls.__name__
        new_cls =  super(MetaClass, cls).__new__(cls, name, bases, attr)
        print 'MetaClass create class:', new_cls.__name__
        return new_cls
        
    def __call__(cls, *args, **kwargs):
        print "MetaClass __call__:", cls.__name__
        return super(MetaClass, cls).__call__(cls, *args, **kwargs)

元类的定义和普通类相同，唯一的区别就是元类必须继承type或者其他元类。
实例化过程也和普通类一样，元类在实例化之前会调用__new__方法来生成一个新的类，这就是元类和普通类的最大区别，接着__new__方法会将新生成的类传递给__init__方法。和普通类一样，如果__new__方法不返回一个类，__init__方法不会被调用。

class MyClass(object):
    __metaclass__ = MetaClass

    def __init__(self, *args, **kwargs):
        print "MyClass __init__"
  
    def __new__(cls, *args, **kwargs):
        print "MyClass __new__"
        return super(MyClass, cls).__new__(cls, *args, **kwargs)
    
    def __call__(self, *args, **kwargs):
        print "MyClass __call__"

代码执行之后输出

MetaClass __new__: MetaClass
MetaClass create class: MyClass
MetaClass __init__: MyClass

Python中一切都是对象，包括类，所以解释器会在解析到类定义的时候，生成一个当前命名空间中唯一的一个类对象。而我在上面说过__metaclass__属性会拦截生解释器生成类对象的过程，上面的输出就证明了这点。

__call__方法在生成类的过程中不会被调用，它会在元类生成的类生成实例之前被调用，有点绕，直接看代码比较清晰。

# MyClass类定义之后加上下面的语句用来生成一个类实例
mc1 = MyClass()

代码执行之后输出

MetaClass __new__: MetaClass
MetaClass create class: MyClass
MetaClass __init__: MyClass
MetaClass __call__: MyClass
MyClass __new__
MyClass __init__

可以看到元类的__call__方法被调用了。
为什么呢？
首选来回顾下__call__方法会在什么情况下被调用？
类如果定义了__call__方法那么就表明类的实例也是一个可调用的对象，比如

class Person(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print "Hello", self.name

>>> p = Person('Tim')
>>> p()
Hello Tim

如果没有__call__方法，类实例p无法被调用。

回到主题，MyClass可以被视作是元类MetaClass的实例，虽然它是一个类，又因为元类实现了__call__方法，所以元类的实例是可调用的。所以在执行MyClass()的时候，才会调用元类的__call__方法。
再说一句，元类继承type之后，可以不用自己实现__call__方法，它的实例就是可调用的，这也是元类和普通类的一个区别。

元类__new__方法的参数

Python 2.7版本中元类的__new__方法会传递4个参数

def __new__(cls, name, bases, attr):
    print "MetaClass.__new__(cls=%s, name=%r, bases=%s, attrs=[%s])" % (cls, name, bases, ", ".join(attr))
    return super(MetaClass, cls).__new__(cls, name, bases, attr)

输出

MetaClass.__new__(cls=<class '__main__.MetaClass'>, name='MyClass', bases=(<type 'object'>,), attrs=[__call__, __module__, __metaclass__, __new__, __init__])
MetaClass __init__: MyClass

cls：元类对象
name：要生成的类的类名
bases：要生成的类的所有父类，是个元组(tuple)
attr：要生成类的所有属性，是个字典

在Python 3.x版本上__new__方法的参数有了变动，可以传递额外的参数了。

class MetaClass(type):
    def __new__(cls, name, bases, attr, **options):
        print('name=%s, bases=%s, attr=[%s], **%s' % (name, bases, ', '.join(attr), options))
        return super(MetaClass, cls).__new__(cls, name, bases, attr)

class MyClass(metaclass=MetaClass, extra=1):
    pass

输出

name=MyClass, bases=(), attr=[__module__, __qualname__], **{'extra': 1}

可以看到extra作为一个关键字参数被传递给了__new__方法

总结

元类作为Python中的黑魔法，虽然用到的机会不多，但技多不压身，多懂点总是没有错的。何况Django的ORM就用到了元类，了解元类可以更好的理解ORM代码。推荐廖雪峰老师用元类实现ORM的教程——Day 3 – 编写ORM，看了之后会对元类有更深的理解。

以上就是目前我对元类的全部理解，记于 2018-03-27

参考：
http://blog.jobbole.com/21351/
https://stackoverflow.com/a/6581949/9500863
https://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/
http://martyalchin.com/2011/jan/20/class-level-keyword-arguments/