[Python知识库]python3.7源码剖析——python对象

学习陈儒老师的《Python源码剖析》
我用的源码为python3.7，所以做了一些改动

PyObject

在python中万物皆对象，对象拥有相同的一些内容，这些定义在PyObject中

[object.h]
typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

_PyObject_HEAD_EXTRA宏 其实在release模式下编译python不会定义符号PyTRACE_REFS
所以 #define _PyObject_HEAD_EXTRA 是空白

[object.h]
#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

/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD                   PyObject ob_base;                 PyObject ob_base;

那么PyObject就变为了

typedef struct _object {
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

Py_ssize_t ob_refcnt 跟python的内存管理机制有关，他实现了基于引用计数的垃圾收集机制，当引用计数减少到0时，就可以从堆上被删除，释放内存




struct _typeobject *ob_type 是一个指向_typeObject结构体指针，他来指定一个对象类型的类型，因为其实相同类型执行操作的操作是一样的，所以放在ob_type所指向的类型对象的中

当然，每个对象除了这个头还会有他们特有的一些东西，PyObject对象里面是别的对象共有的，因为对于结构体头部都是这个的话我们是可以用PyObject*类型的指针轻松访问到任意结构体的头部信息中的ob_refcnt与ob_type（只要结构体的头部固定是这些内容）那么除了这个头部，其他不同的对象有其他不同的额外东西

[longobject.h]
typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
[longintrepr.h]
struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

对于整数来说 他的头部是一个变长对象的头部（python3中的整数没有大小限制，所以源码中不是单纯的用int型去存储他的值，而是用可以变化大小的动态数组，这个结构体尾部大小会在创建的时候确定大小这里默认是1），这个会根据ob_size属性的大小来确定大小，ob_size是变成对象(结构体)拥用的成员

定长与变长对象

对于变定长对象来说，他需要的空间是无法确定的，就是你不可能把他的大小写死，那么这个结构体需要分配的存储数据那块的内存大小就是需要根据实际对象的长度改变的

[object.h]
typedef struct {
    PyObject ob_base; //一个定长结构体PyObject
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

这是变长对象的结构体头部 可以看出来他的头部首先是一个定长对象结构体，然后是一个控制长度大小的ob_size, 从头部来看也就是说变长对象也是可以通过PyObject*去访问到ob_refcnt，ob_type这两个属性的，因为他们的偏移量一样，ob_size这个成员实际上就是指明了变长对象中一共容纳了多少元素

类型对象

[object.h]
typedef struct _typeobject {
    PyObject_VAR_HEAD
    const char *tp_name; /* For printing, in format "<module>.<name>" */
    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

    /* Methods to implement standard operations */

    destructor tp_dealloc;
    printfunc tp_print;
    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;

    /* Method suites for standard classes */

    PyNumberMethods *tp_as_number;
    PySequenceMethods *tp_as_sequence;
    PyMappingMethods *tp_as_mapping;
    ...
    ...
#ifdef COUNT_ALLOCS
    /* these must be last and never explicitly initialized */
    Py_ssize_t tp_allocs;
    Py_ssize_t tp_frees;
    Py_ssize_t tp_maxalloc;
    struct _typeobject *tp_prev;
    struct _typeobject *tp_next;
#endif
} PyTypeObject;

PyObject_VAR_HEAD 宏

#define PyObject_VAR_HEAD      PyVarObject ob_base;

可以看出来 type_object对象是一个变长对象的头部，也就是说它具备ob_size成员，且与PyVarObject一样头部可以用PyObject*访问ob_refcnt, *ob_type

对象的行为

[object.h]
typedef struct _typeobject {
    PyObject_VAR_HEAD
    const char *tp_name; /* For printing, in format "<module>.<name>" */
    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

    /* Methods to implement standard operations */

    destructor tp_dealloc;
    printfunc tp_print;
    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;

    /* Method suites for standard classes */

    PyNumberMethods *tp_as_number;
    PySequenceMethods *tp_as_sequence;
    PyMappingMethods *tp_as_mapping;
    ...
    ...
} PyTypeObject;

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

可以从名字上看出这三个方法分别是作为数字的方法，作为序列的方法，作为字典的方法
这也是为什么在python中其实只要我们实现了特定的方法就可以获得序列的操作，比如实现__add__方法可以实现加法，__getitem__可以实现序列的相关操作

类型的类型

因为PyTypeObject的头部是一个PyObject_VAR_HEAD(PyVarObject ob_base)说明它的最头部还嵌套了一个(PyObject)，而PyObject类型里面有一个ob_type指针指向一个PyTypeObject

[object.h]
typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

类型的类型也就是ob_type指向的还是一个PyTypeObject,下面是他指向的结构体，里面初始化了一些数据

[typeobject.c]
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 
    ...
};

头部的宏

#define PyObject_HEAD_INIT(type)        \
    { _PyObject_EXTRA_INIT              \
    1, type },

#define PyVarObject_HEAD_INIT(type, size)       \
    { PyObject_HEAD_INIT(type) size },

可以看出来是初始化了PyVarObject头部的值，默认为

{
    {   
        _PyObject_EXTRA_INIT //前面说过是空白的
        1 // 引用计数为1
        type: PyType_Type 指向自己
    } PyObject结构体部分
    size：0 //变长对象，默认长度给了0
}PyVarObject结构体部分

总结

有些是自己的理解，可有错误，欢迎大佬们指正~