python源码分析----对象结构

虽然自己会吐槽python这语言让人受不了的慢，不过也不得不说python语言在语法上的精炼，在写代码的时候确实会比java方便一些。。。不过由于python无法像java一样项目的开始先定义一套强类型限制的接口，所以总感觉在写python的时候有点不踏实。。。不过pycharm从某种程度上通过注释也能减轻一点这方面的担忧。。

好了。。。。。决定了要看一下python的实现。。。这里就先从python的对象结构来说吧。。。。

在python中，所有的东西都是对象，整数是，方法也是，。。总之什么都是。。。。

在看python的代码实现中，可以随处看到指针类型：PyObject*，那么我们就先来看看PyObject这到底是怎么定义的吧：

typedef struct _object { //这个是所有python对象的基础，这个是不可变对象
PyObject_HEAD
} PyObject;

他就是整个python环境中最上层的对象结构，很简单，就包括一个对象头部，那么来看看它的定义：
//通过这个结构，将所有对象构成一个双链表
/* 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

//所有对象共有的数据，这个放在所有对象内存的最开始部分，首先是构成对象链表的前后执指针，其次是引用数量，以及它的类型对象
/**
(1)前后指针，构成循环链表
（2）引用计数
（3）类型对象
**/
/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD \
_PyObject_HEAD_EXTRA \
Py_ssize_t ob_refcnt; \
struct _typeobject *ob_type;

可以看出，头部由3部分来构成，首先是一个前后指针，用于将对象构成一个双向的链表，其次就是比较重要的引用计数了。。。然后还有就是类型对象----》每一个对象都有一个指针指向其所指向的类型对象。。。

既然看到了引用计数，那么就来说说python的GC吧。。。它跟java在GC最大的不同点就是有一套基于引用计数的内存回收。。。

（1）每一个对象都关联一个引用计数，当这个计数为0的时候，那么它的内存就可以被回收了

（2）对于有循环引用的情况，python也有一套可达性分析的gc来回收内存。。当然它这部分就比java简单的多了

上面看的时最基础的PyObject结构。。。另外这里还有另外一种结构：PyVarObject，它用于指代一些变长对象，主要是一些容器。。。。//一般都是一些容器啥的
typedef struct { //可变对象的基础
PyObject_VAR_HEAD
} PyVarObject;

//即使是可变对象，首先也是有一个统一的对象头部，ob_size一般用于记录容器中数据项个数，注意这里不是字节数
#define PyObject_VAR_HEAD \
PyObject_HEAD \
Py_ssize_t ob_size; /* Number of items in variable part */
#define Py_INVALID_SIZE (Py_ssize_t)-1

它其实也就是扩展了一个0b_size字段。。。本质上也是与PyObject统一的。。。。所以对于PyVarObject，也可以用PyObject指针来引用。。从而达到了统一。。。。

通过上面的内容，我们知道，所有的对象，都会有一个ob_type指针域，用于指向当前对象的类型对象，那么接下来来看看类型对象的定义：//这个用来指定一个对象的类型对象
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; //在调用print打印类型的时候，将会调用这里来进行输出
getattrfunc tp_getattr; //getter函数
setattrfunc tp_setattr; //setter函数
cmpfunc tp_compare; //比较函数
reprfunc tp_repr; //转化为字符串

/* Method suites for standard classes */

PyNumberMethods *tp_as_number; //最为数字的进行操作的函数
PySequenceMethods *tp_as_sequence; //作为序列进行操作的函数
PyMappingMethods *tp_as_mapping; //作为字典进行操作的函数

/* More standard operations (here for binary compatibility) */

hashfunc tp_hash; //获取hash值的函数
ternaryfunc tp_call; //作为方法进行调用的时候
reprfunc tp_str;
getattrofunc tp_getattro;
setattrofunc tp_setattro;

/* Functions to access object as input/output buffer */
PyBufferProcs *tp_as_buffer; //将当前对象作为buffer进行处理的时候的方法

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

const char *tp_doc; /* Documentation string */ //当前类型的文档

/* Assigned meaning in release 2.0 */
/* call function for all accessible objects */
traverseproc tp_traverse;

/* delete references to contained objects */
inquiry tp_clear;

/* Assigned meaning in release 2.1 */
/* rich comparisons */
richcmpfunc tp_richcompare;

/* weak reference enabler */
Py_ssize_t tp_weaklistoffset;

/* Added in release 2.2 */
/* Iterators */
getiterfunc tp_iter;
iternextfunc tp_iternext;

/* Attribute descriptor and subclassing stuff */
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;

/* Type attribute cache version tag. Added in version 2.6 */
unsigned int tp_version_tag;

#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

那么也就是说，类型对象本身也是一个对象，也可以用PyObject指针来引用。。。。

嗯。。那么。。这里问题就来了。。。。既然类型对象也是一个对象。。。。那么类型对象他自己的类型对象是啥呢。。。？

嗯。。。在python中定义了一个最顶层的类型对象。。。。。//最顶层的类型对象，它进行一个类型对象的自引用
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 */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)type_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)_Py_HashPointer, /* tp_hash */
(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, /* tp_flags */
type_doc, /* tp_doc */
(traverseproc)type_traverse, /* tp_traverse */
(inquiry)type_clear, /* tp_clear */
type_richcompare, /* 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 */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
offsetof(PyTypeObject, tp_dict), /* tp_dictoffset */
type_init, /* tp_init */
0, /* tp_alloc */
type_new, /* tp_new */
PyObject_GC_Del, /* tp_free */
(inquiry)type_is_gc, /* tp_is_gc */
};
这里可以看到它的类型对象本身引用了自己。。。。。

以后可以看到，所有的python类型对象都将它自己的类型对象指向了PyType_Type

好了。。基本上比较粗略的了解了python的对象结构。。。。。