python2参数元信息_2.1.5 Python元类深刻理解(metaclass)

本节目录

类创建过程中所需要的信息

一个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 ()

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)

复制代码

从实例代码的执行结果也可以得到印证：

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

print(obj.__class__) #

print(obj.__class__.__class__) #

print(obj.__class__.__class__.__class__) #

print(obj.__class__.__class__.__class__.__class__) #

复制代码