参考：https://www.toutiao.com/i6481954430865375757/
https://www.keakon.net/2009/04/12/Python%E7%9A%84metaclass
类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。而对于python，经常会听到，在Python中，一切皆对象，对象是类的实例化体现。那么类是怎么来的呢？
在python中，经常见到声明一个类用class Hello(object)种方式，python解释器遇到class Hello(object)这句，是怎么处理的呢？object这个类又是怎么来的呢？
首先类也是一个对象， 这个对象由哪个类实例化的呢？ 答案就是元类，通常就是type 或者继承type的类。所以需要创建一个类的时候，我们可以有以下三种方式：
第一种：
class TestClass(object): # 当python解释器解释完这句的时候，就已经帮我们生成了一个TestClass类
def __new__(cls, *args, **kwargs): #这个 __new__是在实例化TestClass类的时候负责在内存中创建TestClass类对象
return super(TestClass, cls).__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs): #这个__init__是在实例化TestClass类的时候负责初始化__new__创建好的对象
self.args = args
self.kwargs = kwargs
第二种：
TestClass=type("TestClass", (object,), {})
第三种,也是对第一种的定制和改进:
class MyMetaClass(type):
def __new__(cls, name, base, attr):
return super(MyMetaClass, cls).__new__(cls, name, base, attr)
def __init__(self, name, base, attr): #可要可不要
super(MyMetaClass, cls).__init__(name, base, attr)
class TestClass(object):
__metaclass__ = MyMetaClass
先来猜测性的解释一下第一种方式，也就是只用class TestClass(object)去声明。当python 解释器看到class的声明时， 会先收集class语句范围类声明的变量，以k-v的形式放到字典attr中， 然后寻找metaclass， 因为TestClass中没有定义，就去父类object中找，也没有，最后就直接调用type， 将"TestClass", (object,) , attr三个参数传给type生成TestClass对象。
然后我们在调用TestClass类实例化对象时，通常的调用方式就是TestClass("参数")， 上面我们已经说了，TestClass已经是一个对象了，这里应该想到__call__魔法函数，TestClass("参数")也就是调用TestClass对象的__call__函数， 但是我们并没有定义__call__函数,这个__call__函数从哪儿来呢。研究过python的MRO的话，应该比较清楚，自身如果没有某个函数或者方法，就会去找父类，或者兄弟类。 所以这里就回去找object中的__call__方法，而object中的__call__方法会做什么呢， 会去调用TestClass中定义的__new__和__init__方法(需要去看python源码)，这就到了我们看的见的流程了。通常我们并没有定义__new__方法，所以 还是按照MRO，最后调用的父类的__new__,通常就是type的__new__或者object的__new__方法。
调用元类"__call__"函数这个点，也可以通过元类的单例模式的实现得到验证,因为单例模式就是一个类只能有一个实例，他的实现就是重写元类的"__call__方法"，实现如下：
class MyMetaClass(type):
def __init__(cls,name, base, attr):
super(MymetaClass, cls).__init__(name, base, attr)
cls._instance = None
def __call__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super(MyMetaClass, cls).__call__(*args, **kargs)
return cls._instance
class A():
__metaclass__ = MyMetaClass
这样从类的创建，到类的实例化过程就完了。这中间python为我们做了很多事情，很多就是python的黑魔法。 当我们想自己定制一个类，这个类和其他很多类一样，包含很多共同的特性的时候， 我们就可以用到元类了(当然也可以用基类)，也就是第三种方法。
第三种声明类的方式的时候，因为TestClass中声明了__metaclass__ ，所以会去调用MyMetaClass的__new__和__init__去创建TestClass这个类对象向，这个时候，我们就可以在__new__和__init__中做很多处理，这也就是__metaclass__ 存在的一个很重要的意义。 这里需要明确的就是MyMetaClass中的__new__和__init__的参数，name 就是"TestClass", base就是(object,)，attr就是一个字典，存放的是收集TestClass的属性，比如__new__和__init__， 然后返回一个TestClass类。
看下面的例子
#!/usr/bin/env python
#-*- coding: utf-8 -*-
class MyMetaClass(type):
def __new__(cls, name, base, attr):
print ""
print "mateclass new"
print name
print base
print attr
attr.update({"age": 27, "six": "boy"}) # 测试1
print "id attr['__new__']: ", id(attr['__new__'])
# attr = {"age": 27, "six": "boy"} # 测试2
# attr = {"age": 27, "six": "boy", "__new__": attr['__new__'], "__init__": attr["__init__"]} # 测试3
a = super(MyMetaClass, cls).__new__(cls, name, base, attr)
print type(a), " xxxxx"
return a
def __init__(self, name, base, attr):
print ""
print "mateclass init"
print name
print base
print attr
# def __call__(cls, *args, **kwds):
# print '__call__ of ', str(cls)
# print '__call__ *args=', str(args)
# return type(cls, *args, **kwds)
class TestObj(object):
__metaclass__ = MyMetaClass
A = "xxx"
B = "YYY"
C = "xxxx"
def __new__(cls, *args, **kwargs):
print ""
print "TestObj new"
print cls
print args
print kwargs
return super(TestObj, cls).__new__(cls, *args, **kwargs)
def __init__(self, x, y, z):
print "TestObj init"
self.x = x
self.y = y
self.z = z
print "id(__new__): ", id(TestObj.__new__)
if __name__ == "__main__":
pass
# a = TestObj(1, 2, 3)
# print a.age
上面的代码的运行结果是
mateclass new
TestObj
(<type 'object'>,)
{'A': 'xxx', '__module__': '__main__', 'B': 'YYY', '__metaclass__': <class '__main__.MyMetaClass'>, '__new__': <function __new__ at 0x7f68fdddd668>, 'C': 'xxxx', '__init__': <function __init__ at 0x7f68fdddd6e0>}
id attr['__new__']: 140088912500328
<class '__main__.MyMetaClass'> xxxxx
mateclass init
TestObj
(<type 'object'>,)
{'A': 'xxx', '__module__': '__main__', 'B': 'YYY', '__metaclass__': <class '__main__.MyMetaClass'>, '__new__': <function __new__ at 0x7f68fdddd668>, 'age': 27, 'six': 'boy', 'C': 'xxxx', '__init__': <function __init__ at 0x7f68fdddd6e0>}
id(__new__): 140088912500328
从结果中我们可以看出，MyMetaClass类中的中的 attr['__new__']的id是 140088912500328，和直接print "id(__new__): ", id(TestObj.__new__)的id 是一样的，就验证了上面对执行流程的猜测。同时在if __name__ == "__main__":语句块中，我们没有做任何操作，为什么还会调用mateclass new和mateclass init呢， 答案就是python对class MyMetaClass解释时， 调用了元类MyMetaClass生成了MyMetaClass类。
当把if __name__ == "__main__":语句块中的注释取消掉，就会发现多了如下输出：
TestObj new
<class '__main__.TestObj'>
(1, 2, 3)
{}
TestObj init
27
age明明是TestObj这个类的，为什么a能直接调用呢？(回想一下上面的创建对象的函数调用流程，元类的__call__函数去调用类定义的__new__和__init__，那调用时传递的参数从哪儿来？应该就是元类收集类定义的数据，然后放到的attr中，最后调用__call__的时候同样用了attr)。
试想一下，A, B, C这三个变量是不是也是类TestObj的，我们也会在代码中经常通过实例比如a直接去访问。 所以在元类MyMetaClass中为TestObj 类新增的属性age, six就是metaclass的一个小小的作用，只要其他类都想TestObj类一样通过__metaclass__ = MyMetaClass 或者class TestObj(obj, metaclass=MyMetaClass)这种方式去引用了MyMetaClass，那么生成的类和类的实例都会有age, six属性。
测试过程中，还发现，如果直接向测试2的方式直接需修改attr，会出现如下错误
Traceback (most recent call last):
File "/home/xxxx/work/test/python_magic_test.py", line 58, in <module>
a = TestObj(1, 2, 3)
TypeError: object() takes no parameters
对于这个问题懵逼了很久， 请教大神后才发现， 对于测试2(attr = {"age": 27, "six": "boy"} )，直接改变attr，导致attr收集的很多属性丢失了，比如TestObj中定义的__new__和__init__方法，导致MyMetaClass 通过a = super(MyMetaClass, cls).__new__(cls, name, base, attr)创建的TestObj类没有__new__，和__init__方法。 所以在执行a = TestObj(1, 2, 3)的时候，按照MRO先去找TestObj这个类对象的"__call__"方法，但是肯定找不到，我们没有显示的定义，最后调用了父类object的"__call__"，然后"__call__"调用__new__和__init__方法。这两个方法虽然TestObj中定义了，但是在元类生成TestObj类的时候被去掉了，所以也就是没有了，那就继续按照MRO去找咯，也就是找到父类object类，然后object中的__init__方法不需要参数，而TestObj(1, 2, 3)传递了三个，所以就报错啦。具体代码层面的证明，需要阅读python的源码，python的诸多黑魔法，就是python解释器按照特定的语法规则为使用者悄悄的做了很多处理，初期使用起来，看着很简单，很高效，但是越到后面，那些引以为傲的优势，可能就成为你对python认知和学习的障碍。
总结下来：
1.python的类也是对象，这个对象是元类创建的
2.元类可以控制类的生成过程，从而定制一批特殊的类
