本节目录
类创建过程中所需要的信息
一个python类在创建过程中，需要获取两种类型的信息，即:动态元信息，与静态元信息。 所谓动态元信息，是指那些随着类的变化会改变的信息。比如：类名称，类基类，类属性。 而所谓静态元信息，是指与类的种类没有关系的静态信息，这里主要指的是类创建的方式和过程。 我想，对于动态元信息，大家是再熟悉不过了。 而对于静态元信息，其概念显得晦涩难懂。然而它其实有一个响亮的名字：元类。
元类
我们都知道，python 处处皆对象。因此，在python中，类(class)本身也是一个对象(object)，而元类则是类的类型。在我的文章深入理解python之对象系统中，我也曾经梳理过，普通对象(PyXXX_Object)，类对象(PyXXX_Type)，基类对象(PyBaseObject_Type)以及元类(PyType_TYpe)之间的关系。
我们前面提到类的静态元信息，即为元类。也就是说，元类描述了类的创建方式和过程，那么它是如何做到的呢？这里我们阅读如下python源码：
static PyObject *build_class(PyObject *methods, PyObject *bases, PyObject *name){ //methods:类属性列表 //bases:基类元组 //name:类名称 PyObject *metaclass = NULL；//元类 ... //从methods里寻找用户自定义的metaclass，如果找不到，则使用默认的metaclass ... result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods, NULL);}PyObject_CallFunctionObjArgs(PyObject *callable, ...){ ... tmp = PyObject_Call(callable, args, NULL); ... return tmp;}PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw){ //func=metaclass //args=[methods,bases,name] ... call = func->ob_type->tp_call; ... result = (*call)(func, arg, kw); ...}复制代码 build_class 函数是创建类对象过程中的一个核心函数，build_class函数传入的参数是类的动态元信息：属性，类基类，类名。而build_class做的第一件事是,确定类的元类（metaclass）。在找到了元类以后，实际上python底层在这里对元类对象执行了一个 调用（call）的动作，就像调用一个函数对象那样。假设某个类对象的元类对象是metaclass。那么在类创建过程中围绕元类的核心操作如下：
class=metaclass(metaclass，methods，bases，name)复制代码
由此我们可以知道，所谓的类对象的静态元信息，也就是类对象创建的过程与方式，都封装在了某个callable的metaclass对象的函数体内。
与之相对比的，创建某个普通对象的过程也就是对于一个类对象的调用过程：
obj=class(class,...);复制代码
class 是metaclass的实例，所以调用metaclass得到class。而obj是class的实例，所以调用class得到obj。在这里，python “ 处处皆对象”的设计哲学得以很好的体现。我们由此可以做个总结：在python中，类是通过 “调用(call)“的方式创建一个对象。
类创建过程的原理分析
本小节我们通过一个具体的例子去分析，类创建过程中的具体步骤。 实例代码：
class meta(type): '''元类''' def __new__(metacls,name,bases,methods): print metacls，name return type.__new__(metacls,name,bases,methods) def __init__(cls,name,bases,methods): print cls，nameclass T(object): '''类''' __metaclass__=meta #指定元类 a=1 def b(): pass def c(): pass复制代码
首先我们通过compile 函数和dis模块去获取类型T定义过程对应的指令序列：
22 LOAD_CONST 2 ('T')25 LOAD_NAME 2 (object)28 BUILD_TUPLE 131 LOAD_CONST 3 ()34 MAKE_FUNCTION 037 CALL_FUNCTION 040 BUILD_CLASS 41 STORE_NAME 3 (T)44 LOAD_CONST 4 (None)47 RETURN_VALUE复制代码 -
LOAD_CONST 是向当前解释器执行栈内压入类名T。
-
LOAD_NAME 和BUILD_TUPLE指令实际上完成了对于类基类元组(bases)的准备，BUILD_TUPLE 指令执行完成后，当前解释器执行栈上已经存入了函数名和基类元组。
-
LOAD_CONST,MAKE_FUNCTION,CALL_FUNCTION 三条指令，实际上完成了类属性字典的定义与收集。
-
LOAD_CONST 加载的是类中属性定义语句所对应的PyCodeObject。
-
MAKE_FUNCTION 是利用类中属性定义语句的PyCodeObject 创造一个PyFunctionObject
-
CALL_FUNCTION 则是使解释器执行类中属性定义语句的指令序列,从而完成类属性的定义过程。
-
BUILD_CLASS 显然是创建一个类的核心指令，其实际上就是调用了前文所述的build_class函数。
-
STORE_NAME 指令将经过BUILD_CLASS 指令之后创建的类对象，存入名字T所对应的空间，至此，整个类的创建过程结束。
接下来，我们重新回到整个类创建过程的核心build_class 函数。
解释器在处理我们的实例代码过程中，显然有：
//T_pro_dict={ "__metaclass__"=meta,"a":1,"b":...}//T_bases=[object]build_class(T_pro_dict,T_bases,"T");复制代码 所以在PyObject_Call中有：
PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { //func=meta //args=[T_pro_dict,T_bases,"T"] ... call = func->ob_type->tp_call; ... result = (*call)(func, arg, kw); ... }复制代码 这里我们思考，meta->ob_type->tp_call是什么？meta是我们定义的元类对象，作为一个类型对象本身，其ob_type 是指向type对象的，因此meta->ob_type->tp_call 指向的是type对象的tp_call 成员，也就是：PyType_type->tp_call。 继续追踪PyType_type->tp_call的源码：
static PyObject *type_call(PyTypeObject *type, PyObject *args, PyObject *kwds){ //type = meta //args=[T_pro_dict,T_bases,"T"] PyObject *obj; ... obj = type->tp_new(type, args, kwds); ... if(type->tp_init && type != &PyType_Type) type->tp_init(obj, args, kwds)； ... return obj;}复制代码 在pyType_type->tp_call 所对应的函数里，首先调用了metaclass 的new函数，又由于当前元类不是默认的type类型，因此也会执行metaclass的init函数。落实到在我们的示例代码中，显然有如下逻辑得以执行：
class_obj=meta.__new__(meta,"T",T_bases,T_pro_dict)meta.__init__(class_obj,"T",T_bases,T_pro_dict)复制代码
从实例代码的执行结果也可以得到印证：
T T复制代码
通过名字我们不难猜测，这里的_new_ 相当于python 类对象的构造函数，实际负责了类对象内存的申请，动态元信息的填充等工作。而_init_ 则是一个可选的初始化函数，由元类的定制者设计其中的内容。 在我们的实例中，meta._new函数调用了type._new函数完成了类对象的创建，type.new 在python源码中对应的的是type_new函数。
static PyObject *type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds){ PyObject *name, *bases, *dict; ... // 获取目标类的动态元信息：类名，基类元组，属性字典 PyArg_ParseTupleAndKeywords(args, kwds, "SO!O!:type", kwlist, &name, &PyTuple_Type, &bases, &PyDict_Type, &dict); ... // 类对象的内存申请 type = (PyTypeObject *)metatype->tp_alloc(metatype, nslots); /*类对象的动态元信息填充*/ //类名 type->tp_name = PyString_AS_STRING(name); ... //基类 type->tp_bases = bases; ... //属性 type->tp_dict = dict = PyDict_Copy(dict); ... // 类型的其他信息的初始化 PyType_Ready(type); ... return (PyObject *)type;}复制代码 在type_new函数的中，我们可以清楚的看到类对象内存申请，动态元信息填充的具体实现。 至此，一个元类创建一个类的主干过程，就梳理完毕了。
什么是元类呢？在Python3中继承type的就是元类
方式一:
class MyType(type): '''继承type的就是元类''' def __init__(self,*args,**kwargs): print("MyType创建的对象",self) #Foo super(MyType,self).__init__(*args,**kwargs) def __call__(self, *args, **kwargs): obj = super(MyType,self).__call__(*args,**kwargs) print("类创建对象",self,obj) #Fooclass Foo(object,metaclass=MyType): # 对象加括号会去执行__call__方法，__call__方法里面继承了type的__call__方法 ，type的__call__方法里面会先执行__new__方法，再去执行__init__方法。 所以，Foo就是用type创建出来的 user = "haiyan" age = 18obj = Foo()复制代码 方式二:
class MyType(type): def __init__(self, *args, **kwargs): print("ssss") super(MyType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): v = dir(cls) obj = super(MyType, cls).__call__(*args, **kwargs) return obj#对象加括号就会去执行__call__方法class Foo(MyType('Zcc', (object,), {})): #MyType('Zcc', (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类 user = 'haiyan' age = 18obj = Foo()复制代码 方式三:
class MyType(type): def __init__(self, *args, **kwargs): print("ssss") super(MyType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): v = dir(cls) obj = super(MyType, cls).__call__(*args, **kwargs) return obj#对象加括号就会去执行__call__方法def with_metaclass(arg,base): print("类对象",MyType('Zcc', (base,), {})) return arg('Zcc', (base,), {}) #返回一个类对象 class Foo(with_metaclass(MyType,object)): #MyType('Zcc', (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类 user = 'haiyan' age = 18obj = Foo()复制代码 class ASD(type): passqqq = ASD("qwe", (object,), {}) #用ASD这个元类创建了一个（qwe,并且继承object类的）类# class ASD(qwe):# passobj = qqq()# 能创建类的是元类# 能创建对象的是类print(obj) #<__main__.qwe object at 0x00000000024FFBA8>print(obj.__class__) # print(obj.__class__.__class__) # print(obj.__class__.__class__.__class__) # print(obj.__class__.__class__.__class__.__class__) # 复制代码