第1篇:CPython实现原理：万物皆为PyObject

对象的定义

在C/C++中，对象就是堆(Heap)内存中的内存实体，从简单的基本数据类型(int,float,char)到聚合的数据类型(struct)一切皆为对象，我们说基本的数据类型是简单的对象(Simple Object)，因为它仅包含数据属性。而struct级别的数据类型是完整的对象(Concrete Object)，因为完整的对象具有属性和行为两个基本概念。

属性就是结构体的数据字段，可以是基本数据类型，指针类型、甚至是嵌套的struct类型。
行为又称为方法或成员函数,就是struct内部定义的一系列函数指针。

备注：如有疑问：请移至《C++ 面向对象》和《C++ 多态》

Python对象的本源 PyObject

CPython是用C语言实现的，那么用C/C++中关于对象的概念，去理解Python对象也是理所当然的。先看一下CPython中关于PyObject的定义

typedef struct _object {
    _PyObject_HEAD_EXTRA  
    Py_ssize_t ob_refcnt;     //引用计数器，和内存回收有关
    PyTypeObject *ob_type;  //定义Python对象的元类信息
} PyObject;

其实整个PyObject的难点是就是第三个字段PyTyepObject,也是整个PyObject的核心,包括基本的类型信息：类名称，类型尺寸(需要分配多大的内存)以及类绑定的方法(即绑定的函数指针)。后文会详细谈到，而_PyObject_HEAD_EXTRA这个宏的定义如下

#ifdef Py_TRACE_REFS
/* Define pointers to support a doubly-linked list of all live heap objects. */
#define _PyObject_HEAD_EXTRA            \
    struct _object *_ob_next;           \
    struct _object *_ob_prev;

#define _PyObject_EXTRA_INIT 0, 0,

#else
#define _PyObject_HEAD_EXTRA
#define _PyObject_EXTRA_INIT
#endif

而以发布模型的编译CPython源代码的话，_PyObject_HEAD_EXTRA这段宏定义是不存在，因此PyObject的定义可以简化为

typedef struct _object {
    Py_ssize_t ob_refcnt;     //引用计数器，和内存回收有关
    PyTypeObject *ob_type;  //定义Python对象的元类信息
} PyObject;

在Python的世界观中一切皆为PyObject这个话怎么理解呢？在Python语义中，每当我们实例化任意一个Python对象，在其占用的堆内存区块的首个字节就包含一个PyObject定义的副本，除PyObject的相关内存字节副本外，跟随PyObject对象内存副本之后的内存字节是当前对象的内存信息。举个例子，比如PyLongObject,继承PyVarObject,我们先看看位于Include/longintrepr.h定义

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

而PyObject_VAR_HEAD这个宏定义实质上是PyVarObject类型，而PyVarObject本来就继承PyObject,其定义如下Include/object.h

....
#define PyObject_VAR_HEAD      PyVarObject ob_base;
....
typedef struct {
    PyObject ob_base;
    //这是一个指向C类型的数据指针指向的堆内存区域
    //ob_size就是统计该堆内存能够容纳元素个数的计数器
    Py_ssize_t ob_size; 
} PyVarObject;

任何一个Python对象继承PyVarObject，表明它是一个可变长对象（或叫容器对象），其PyLongObject的完整形式的定义如下

struct _longobject{
    PyObject ob_base;   //PyObject的内存副本
    Py_ssize_t ob_size; //数据指针的计数器
    //其实ob_digit是一个堆中的数组，只不过目前指向索引1的元素
    digit ob_digit[1];        
} PyLongObject;

或者是这样

struct _longobject{
    Py_ssize_t ob_refcnt;     //引用计数器，和内存回收有关
    PyTypeObject *ob_type;    //定义Python对象的元类信息
    Py_ssize_t ob_size;       //数据指针的计数器
   //数据指针 ob_digit，而ob_digit[1]标识一个digit类型的数组元素
    digit ob_digit[1];         
} PyLongObject;

好吧！用一个类继承图就比较直观

从内存图的角度来看，如下图所示，PyLongObject类型的对象，我们说当实例化一个PyLongObject的实例，它首先要初始化PyVarObject的内存中的数据(所有字段的默认值)，我们说PyLongObject的实例持有PyVarObject的内存副本。而PyVarObject初始化，也要初始化PyObject的内存数据。换句话说，在Python内部，每个堆吸纳个都拥有相同的对象头部，这使对象的引用变得单一化，只需一个PyObject*指针就可以任意引用一个对象。

备注：其实C++面向对象模型大体上是这么一个套路，只不过C++运行时增加了一些对象访问控制设定，而C实现的PyObject是不存在所谓访问控制设定一回事。

定长对象和变长对象

在CPython 3.x像整数类型的Python对象，其具体的数字字面量ob_digit[1](注意ob_digit是一个unsigned int数组)。例如

>>> n=int(1)
>>> n2=int(9999)
>>> n
1
>>> n2
9999
>>> import sys
>>> sys.getsizeof(n)
28
>>> sys.getsizeof(n2)
28

我们说像int,double这类的基本数据类型，他们不同的实例有固定长度的，我们说这些叫定长对象。而变长对象即对象的类型尺寸是可变的。例如PyStringObject、PyListObject、PyDictObject这些都是可变长对象（也叫容器对象，这和C++标准库的容器对象非常相似了）。容器对象的最基本的特征。其struct内部维护着一个数据指针(指向堆中一片连续的内存区域)，以及一个计数器ob_size就是实时统计该堆内存区域有多少个数据实体。目前仅需简单了解这些概念即可。

PyTypeObject

我们说过任意一个PyObject的实例创建过程中，需要知道类型名，需要分配的堆内存，以及该对象实例配套的行为(即函数指针)，这些信息均包含在PyTypeObject实例中,注意我的描述，这个关键字定义必须牢记。

重要概念: PyTypeObject实例是指在CPython3.x源码中，满足“Py<类型名称>_Type”这样的命名风格的结构体初始化代码都叫PyTypeObject实例。

例如PyLongObject，对应的PyTypeObject实例就是PyLong_Type，PyListObject对应的PyTypeObject实例是PyList_Type,等等。下文会详细谈到。

我们先查看一下PyTypeObject的类定义，如下所示，完整代码见Include/cpython/object.h的第193行-274行。

struct _typeobject {
    PyObject_VAR_HEAD
    const char *tp_name; //类型名称
    //内存分配的类型尺寸
    Py_ssize_t tp_basicsize, tp_itemsize; 
    /* Methods to implement standard operations */

    destructor tp_dealloc;
    Py_ssize_t tp_vectorcall_offset;
    getattrfunc tp_getattr;
    setattrfunc tp_setattr;
    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
                                    or tp_reserved (Python 3) */
    reprfunc tp_repr;

    /* 标准类的匹配的方法 */

    PyNumberMethods *tp_as_number;
    PySequenceMethods *tp_as_sequence;
    PyMappingMethods *tp_as_mapping;

    /* 更多标准操作（此处为二进制兼容性）*/

    hashfunc tp_hash;
    ternaryfunc tp_call;
    reprfunc tp_str;
    getattrofunc tp_getattro;
    setattrofunc tp_setattro;

    //函数来访问对象作为I/O缓冲器
    PyBufferProcs *tp_as_buffer;

    /* Flags to define presence of optional/expanded features */
    unsigned long tp_flags;

    const char *tp_doc; /* Documentation string */
    ...
    //属性描述符和子类相关信息，这里定义
    //这里定义了对象的行为
    struct PyMethodDef *tp_methods;
    struct PyMemberDef *tp_members;
    struct PyGetSetDef *tp_getset;
    struct _typeobject *tp_base;
    PyObject *tp_dict;
    descrgetfunc tp_descr_get;
    descrsetfunc tp_descr_set;
    Py_ssize_t tp_dictoffset;
    initproc tp_init;
    allocfunc tp_alloc;
    newfunc tp_new;
    freefunc tp_free; /* Low-level free-memory routine */
    inquiry tp_is_gc; /* For PyObject_IS_GC */
    PyObject *tp_bases;
    PyObject *tp_mro; /* method resolution order */
    PyObject *tp_cache;
    PyObject *tp_subclasses;
    PyObject *tp_weaklist;
    destructor tp_del;
    .....
}  PyTypeObject;

在PyTypeObject中有三个非常重要的字段，分别是tp_as_number、tp_as_sequence、tp_as_mapping。它们分别指向PyNumberMethod、PySequenceMethods和PyMappingMethods的函数族。

PyNumberMethod:定义了Python对象的行为可以像数字类型执行乘除加减等操作。
PySequenceMethods:定义了Python对象作为一个顺序表一样的行为，例如list。
PyMappingMethods:定义Python对象的关联行为，例如dict

Python对象的类型信息

从PyTypeObject定义中起始字段是一个PyObject_VAR_HEAD,这说明PyTypeObject也是PyObject，正好说明CPython中，一切事物都是Python对象，而每个对象有其一个对应的Type。注意:**不论什么编程语言，当说一个对象是什么类型,即意味最起码的三点信息：1.类型名称、2.类型尺寸、3.对象内存地址。

来看一个例子来展示一下什么是PyTypeObject实例

>>> class Student(object):
...     pass
... 
>>> type(Student)
<class 'type'>
>>> st=Student()
>>> type(st)
<class '__main__.Student'>
>>> i=int(10)
>>> type(i)
<class 'int'>
>>> type(int)
<class 'type'>
>>>

每个用户定义的Python对象的实例可以由其类内部关联的PyTypeObject确定其类型（即type名称、其对象占用堆内存尺寸、对象内存地址...），那么PyTypeObject本身也是Python对象，其类型是什么呢？就是Type类型，当然PyTypeObject的类型由PyType_Type实例来确定。具体的代码见详细代码请查阅Objects/typeobject.c第3738行-3781行。

PyTypeObject PyType_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "type",                                      /* tp_name */
    sizeof(PyHeapTypeObject),                    /* tp_basicsize */
    sizeof(PyMemberDef),                         /* tp_itemsize */
    (destructor)type_dealloc,                    /* tp_dealloc */
    offsetof(PyTypeObject, tp_vectorcall),      /* tp_vectorcall_offset */
    ....
    (ternaryfunc)type_call,                     /* tp_call */
    0,                                          /* tp_str */
    (getattrofunc)type_getattro,                /* tp_getattro */
    (setattrofunc)type_setattro,                /* tp_setattro */
    0,                                          /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
    Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS |
    Py_TPFLAGS_HAVE_VECTORCALL,                 /* tp_flags */
    type_doc,                                   /* tp_doc */
    (traverseproc)type_traverse,                /* tp_traverse */
    (inquiry)type_clear,                        /* tp_clear */
    0,                                          /* tp_richcompare */
    offsetof(PyTypeObject, tp_weaklist),        /* tp_weaklistoffset */
    0,                                          /* tp_iter */
    0,                                          /* tp_iternext */
    type_methods,                               /* tp_methods */
    type_members,                               /* tp_members */
    type_getsets,                               /* tp_getset */
    ....
};

这里需要思考一个问题，当我们在解释器接受到类似type(Student)、type(123)这些语句，CPython内部如何获取其类型信息呢？我们之前说过任何一个Python对象内存头部保存着PyObject的内存副本，更明确地说是引用计数器和PyTypeObject内存副本。在Python中所有class关键字的类定义都通过一个与其对应的PyTypeObject实例来创建该类型的对象。比如Python的int类型对应C层面的PyLongObject类，而PyLongObject的实例化由对应的PyLong_Type实例提供类型信息。如此类推，还有其他常见的Python对象与PyTypeObject实例的对应关系，如下表所示

在CPython的运行时中，所有内置的数据类型已经在C代码中预定义了所有对应类型的PyType_Type实例了，并且这些实例仅在运行时初始化一次

这里我们仍然以PyLongObject为例，当一个我们实例化一个int类型的对象时，CPython内部需要引用对应的PyLong_Type实例内的类型信息。PyLong_Type实例的初始化语句见具体源代码,见Objects/longobject.c的第5671行-5712行，从PyLong_Type源码可知PyVarObject_HEAD_INIT(&PyType_Type，0)宏定义在编译时已经经历过如下的替换过程。

我们说的宏表达式PyVarObject_HEAD_INIT(&PyType_Type)最终等价于

{{0,0,1, &PyType_Type },0},

那么PyLong_Type实例的最终代码形式，如下所示，

PyTypeObject PyLong_Type = {
    {{0,0,1, &PyType_Type },0},
    "int",                                      /* tp_name */
    offsetof(PyLongObject, ob_digit),           /* tp_basicsize */
    sizeof(digit),                              /* tp_itemsize */
    ....
    long_to_decimal_string,                     /* tp_repr */
    &long_as_number,                            /* tp_as_number */
    ....
    (hashfunc)long_hash,                        /* tp_hash */
    ....
    PyObject_GenericGetAttr,                    /* tp_getattro */
    ....
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
        Py_TPFLAGS_LONG_SUBCLASS,               /* tp_flags */
    long_doc,                                   /* tp_doc */
    ....
    long_richcompare,                           /* tp_richcompare */
    ....
    long_methods,                               /* tp_methods */
    ....
    long_getset,                                /* tp_getset */
    ....
    long_new,                                   /* tp_new */
    PyObject_Del,                               /* tp_free */
};

如果，你上面代码还没有概念的话，我们通过一个实例来说明一些基本的事实，首先我们在Python解释器交互命令行创建一个比较无聊的num函数，该函数旨在其内部实例化一个PyLongObject的实例m

可以用gdb工具执行Python解释器，我们通过对Python/ceval.c源码关于LOAD_CONST指令定义的C代码的执行断点，

使用print *value命令,可以知道初始化一个PyLongObject实例时，它的ob_type字段是指向PyLong_Type实例的内存地址。
通过print一下*(value->ob_type)，我们得到PyLong_Type实例的所有具体细节，该PyLong_Type实例的ob_type字段指向一个PyType_Type实例的内存地址,并且tp_base字段是指向一个PyBaseObject_Type的实例。

药不要停，如此类推我们通过print打印ob_base找到当前PyType_Type子类实例的本体，通过ob_type找到上一级实例的

显然，根据PyVarObject_HEAD_INIT(&PyType_Type，0)可知，在PyLongObject实例化过程中,会引用PyLong_Type实例，而PyLong_Type实例也会引用PyType_Type实例。而PyType_Type实例是整个CPython类型系统的根，也就是说PyType_Type是所有Python对象的元类。我们可以通过一个内存图来得到一个清晰的轮廓

咦，这不就是类似C++类继承的原理吗?不用猜。就是，同时这也是体现CPython面向对象模式中的另一个特征--多态。