本节目录
一、创建类的执行流程
二、元类的认识
三、元类的示例
一、创建类的执行流程
类创建过程中所需要的信息
一个python类在创建过程中，需要获取两种类型的信息，即:动态元信息，与静态元信息。
所谓动态元信息，是指那些随着类的变化会改变的信息。比如：类名称，类基类，类属性。
而所谓静态元信息，是指与类的种类没有关系的静态信息，这里主要指的是类创建的方式和过程。
我想，对于动态元信息，大家是再熟悉不过了。
而对于静态元信息，其概念显得晦涩难懂。然而它其实有一个响亮的名字：元类。
元类
我们都知道，python 处处皆对象。因此，在python中，类(class)本身也是一个对象(object)，而元类则是类的类型。在我的文章深入理解python之对象系统中，我也曾经梳理过，普通对象(PyXXX_Object)，类对象(PyXXX_Type)，基类对象(PyBaseObject_Type)以及元类(PyType_TYpe)之间的关系。
如果没有指定，那么所有类的类型（ob_type）都指向type对象(PyType_Type)。也就是说所有类型对象的默认元类就是这个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，name
class 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 1
31 LOAD_CONST 3 (<code object T at 0x1013eac30, file "", line 18>)
34 MAKE_FUNCTION 0
37 CALL_FUNCTION 0
40 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)
从实例代码的执行结果也可以得到印证：
<class '__main__.meta'> T
<class '__main__.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) #Foo
class Foo(object,metaclass=MyType): # 对象加括号会去执行__call__方法，__call__方法里面继承了type的__call__方法
，type的__call__方法里面会先执行__new__方法，再去执行__init__方法。
所以，Foo就是用type创建出来的
user = "haiyan"
age = 18
obj = 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 = 18
obj = 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 '__main__.Zcc'>
class Foo(with_metaclass(MyType,object)): #MyType('Zcc', (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类
user = 'haiyan'
age = 18
obj = Foo()
class ASD(type):
pass
qqq = ASD("qwe", (object,), {}) #用ASD这个元类创建了一个（qwe,并且继承object类的）类
# class ASD(qwe):
# pass
obj = qqq()
# 能创建类的是元类
# 能创建对象的是类
print(obj) #<__main__.qwe object at 0x00000000024FFBA8>
print(obj.__class__) #<class '__main__.qwe'>
print(obj.__class__.__class__) #<class '__main__.ASD'>
print(obj.__class__.__class__.__class__) #<class 'type'>
print(obj.__class__.__class__.__class__.__class__) #<class 'type'>
