类是面向对象编程理论的基础，python作为一门支持面向对象的语言，其在类的创建机制上，与传统的编译型静态语言有着显著的不同。本文即是对python类型的创建过程的梳理。
本文在讨论过程中，涉及到了对于python底层用于描述对象和类的各类数据结构，例如PyObject，PyTypeObject，PyBaseObject_Type, PyType_Type 。它们之间的关系，以及它们具体如何描述python的对象与类，请参考我的另一篇文章：深入理解python之对象系统。而对于python指令序列的更加详细的整理和介绍，请参考深入理解python之opcode备忘录

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

一个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函数的中，我们可以清楚的看到类对象内存申请，动态元信息填充的具体实现。
至此，一个元类创建一个类的主干过程，就梳理完毕了。