2.1.5 Python元类深刻理解(metaclass)

点击跳转Python笔记总目录

本节目录

一、创建类的执行流程

二、元类的认识

三、元类的示例

---

一、创建类的执行流程

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

一个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'>
复制代码

转载于:https://juejin.im/post/5c4589f0e51d4507fb1d7962