Python 对象初探
在 Python 的世界一切皆对象,不论是整数,还是字符串,甚至连类型、函数等都是一种对象。
对象的分类
以下是 Python 对象的大致的一个分类
- Fundamental 对象: 类型对象
- Numeric 对象: 数值对象
- Sequence 对象: 容纳其他对象的序列集合对象
- Mapping 对象: 类似 C++中的 map 的关联对象
- Internal 对象: Python 虚拟机在运行时内部使用的对象
对象机制的基石 PyObject
对于初学者来说这么多类型的对象怎么学?别着急,我们后续章节会解答。
在开始我们的学习之旅之前,我们要先认识一个结构体PyObject,可以说 Python 的对象机制就是基于PyObject拓展开来的,所以我们先看看PyObject 到底长什么样。
源文件:
Include/object.h
// Include/object.h
#define _PyObject_HEAD_EXTRA \
struct _object *_ob_next; \
struct _object *_ob_prev;
typedef struct _object {
_PyObject_HEAD_EXTRA // 双向链表 垃圾回收 需要用到
Py_ssize_t ob_refcnt; // 引用计数
struct _typeobject *ob_type; // 指向类型对象的指针,决定了对象的类型
} PyObject;
Python 中的所有对象都拥有一些相同的内容,而这些内容就定义在PyObject中,
PyObject 包含 一个用于垃圾回收的双向链表,一个引用计数变量 ob_refcnt
和 一个类型对象指针ob_type
定长对象与变长对象
Python 对象除了前面提到的那种分类方法外,还可以分为定长对象和变长对象这两种形式。
变长对象都拥有一个相同的内容 PyVarObject,而 PyVarObject也是基于PyObject扩展的。
从代码中可以看出PyVarObject比PyObject多出了一个用于存储元素个数的变量ob_size。
源文件:
Include/object.h
// Include/object.h
typedef struct _object {
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
typedef struct {
PyObject ob_base;
Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
类型对象
前面我们提到了PyObject 的 对象类型指针struct _typeobject *ob_type
,它指向的类型对象就决定了一个对象是什么类型的。
这是一个非常重要的结构体,它不仅仅决定了一个对象的类型,还包含大量的元信息
,
包括创建对象需要分配多少内存,对象都支持哪些操作等等。
接下来我们看一下struct _typeobject
代码
在 PyTypeObject 的定义中包含许多信息,主要分类以下几类:
- 类型名, tp_name, 主要用于 Python 内部调试用
- 创建该类型对象时分配的空间大小信息,即
tp_basicsize
和tp_itemsize
- 与该类型对象相关的操作信息(如
tp_print
这样的函数指针) - 一些对象属性
源文件:
Include/object.h
// Include/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; // 字典对象操作
// 更多标准操作
/* More standard operations (here for binary compatibility) */
hashfunc tp_hash;
ternaryfunc tp_call;
reprfunc tp_str;
getattrofunc tp_getattro;
setattrofunc tp_setattro;
......
} PyTypeObject;
类型的类型
在 PyTypeObjet 定义开始有一个宏PyOject_VAR_HEAD
,查看源码可知 PyTypeObjet 是一个变长对象
源文件:
Include/object.h
// Include/object.h
#define PyObject_VAR_HEAD PyVarObject ob_base;
对象的类型是由该对象指向的 类型对象 决定的,那么类型对象的类型是由谁决定的呢?
对于其他对象,可以通过与其关联的类型对象确定其类型,那么通过什么来确定一个对象是类型对象呢?
答案就是 PyType_Type
// Objects/typeobject.c
PyTypeObject PyType_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"type", /* tp_name */
sizeof(PyHeapTypeObject), /* tp_basicsize */
sizeof(PyMemberDef), /* tp_itemsize */
......
};
PyType_Type
在类型机制中至关重要,所有用户自定义 class
所
对应的 PyTypeObject
对象都是通过 PyType_Type
创建的
接下来我们看 PyLong_Type
是怎么与 PyType_Type
建立联系的。
前面提到,在 Python 中,每一个对象都将自己的引用计数、类型信息保存在开始的部分中。
为了方便对这部分内存初始化,Python 中提供了几个有用的宏:
源文件:
Include/object.h
// Include/object.h
#ifdef Py_TRACE_REFS
#define _PyObject_EXTRA_INIT 0, 0,
#else
#define _PyObject_EXTRA_INIT
#endif
#define PyObject_HEAD_INIT(type) \
{ _PyObject_EXTRA_INIT \
1, type },
这些宏在各种内建类型对象的初始化中被大量使用。
以PyLong_Type
为例,可以清晰的看到一般的类型对象和PyType_Type
之间的关系
// Objects/longobject.c
PyTypeObject PyLong_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"int", /* tp_name */
offsetof(PyLongObject, ob_digit), /* tp_basicsize */
sizeof(digit), /* tp_itemsize */
......
};
下图是对象运行时的图像表现
对象的创建
Python 创建对象有两种方式
范型 API 或称为 AOL (Abstract Object Layer)
这类 API 通常形如PyObject_XXX
这样的形式。可以应用在任何 Python 对象上,
如PyObject_New
。创建一个整数对象的方式
PyObject* longobj = PyObject_New(Pyobject, &PyLong_Type);
与类型相关的 API 或称为 COL (Concrete Object Layer)
这类 API 通常只能作用于某一种类型的对象上,对于每一种内建对象 Python 都提供了这样一组 API。例如整数对象,我们可以利用如下的 API 创建
PyObject *longObj = PyLong_FromLong(10);
对象的行为
在 PyTypeObject 中定义了大量的函数指针。这些函数指针可以视为类型对象中
所定义的操作,这些操作直接决定着一个对象在运行时所表现出的行为,比如 PyTypeObject 中的 tp_hash
指明了该类型对象如何生成其hash
值。
在PyTypeObject的代码中,我们还可以看到非常重要的三组操作族
PyNumberMethods *tp_as_number
PySequenceMethods *tp_as_sequence
PyMappingMethods *tp_as_mapping
PyNumberMethods 的代码如下
源文件:
Include/object.h
// Include/object.h
typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
typedef struct {
binaryfunc nb_matrix_multiply;
binaryfunc nb_inplace_matrix_multiply;
......
} PyNumberMethods;
PyNumberMethods 定义了一个数值对象该支持的操作。一个数值对象如 整数对象,那么它的类型对象 PyLong_Type
中tp_as_number.nb_add
就指定了它进行加法操作时的具体行为。
在以下代码中可以看出PyLong_Type
中的tp_as_number
项指向的是long_as_number
// Objects/longobject.c
static PyNumberMethods long_as_number = {
(binaryfunc)long_add, /*nb_add*/
(binaryfunc)long_sub, /*nb_subtract*/
(binaryfunc)long_mul, /*nb_multiply*/
......
};
PyTypeObject PyLong_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"int", /* tp_name */
offsetof(PyLongObject, ob_digit), /* tp_basicsize */
sizeof(digit), /* tp_itemsize */
long_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
long_to_decimal_string, /* tp_repr */
&long_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
......
};
PySequenceMethods *tp_as_sequence
和 PyMappingMethods *tp_as_mapping
的分析与PyNumberMethods *tp_as_number
相同,大家可以自行查阅源码
对象的多态性
Python 创建一个对象比如 PyLongObject 时,会分配内存进行初始化,然后
Python 内部会用 PyObject*
变量来维护这个对象,其他对象也与此类似
所以在 Python 内部各个函数之间传递的都是一种范型指针 PyObject*
我们不知道这个指针所指的对象是什么类型,只能通过所指对象的 ob_type
域
动态进行判断,而 Python 正是通过 ob_type
实现了多态机制
考虑以下的 calc_hash 函数
Py_hash_t
calc_hash(PyObject* object)
{
Py_hash_t hash = object->ob_type->tp_hash(object);
return hash;
}
如果传递给 calc_hash 函数的指针是一个 PyLongObject*
,那么它会调用 PyLongObject 对象对应的类型对象中定义的 hash 操作tp_hash
,tp_hash
可以在PyTypeObject中找到,
而具体赋值绑定我们可以在 PyLong_Type
初始化代码中看到绑定的是long_hash
函数
// Objects/longobject.c
PyTypeObject PyLong_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"int", /* tp_name */
...
(hashfunc)long_hash, /* tp_hash */
...
};
如果指针是一个 PyUnicodeObject*
,那么就会调用 PyUnicodeObject 对象对应的类型对象中定义的 hash 操作,查看源码可以看到 实际绑定的是 unicode_hash
函数
// Objects/unicodeobject.c
PyTypeObject PyUnicode_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"str", /* tp_name */
...
(hashfunc) unicode_hash, /* tp_hash*/
...
};
引用计数
Python 通过引用计数来管理维护对象在内存中的存在与否
Python 中的每个东西都是一个对象, 都有ob_refcnt
变量,这个变量维护对象的引用计数,从而最终决定该对象的创建与销毁
在 Python 中,主要通过 Py_INCREF(op)
与Py_DECREF(op)
这两个宏
来增加和减少对一个对象的引用计数。当一个对象的引用计数减少到 0 之后,
Py_DECREF
将调用该对象的tp_dealloc
来释放对象所占用的内存和系统资源;
但这并不意味着最终一定会调用 free
释放内存空间。因为频繁的申请、释放内存会大大降低 Python 的执行效率。因此 Python 中大量采用了内存对象池的技术,使得对象释放的空间归还给内存池而不是直接free
,后续使用可先从对象池中获取
源文件:
Include/object.h
// Include/object.h
#define _Py_NewReference(op) ( \
_Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \
_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
Py_REFCNT(op) = 1)
#define Py_INCREF(op) ( \
_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \
((PyObject *)(op))->ob_refcnt++)
#define Py_DECREF(op) \
do { \
PyObject *_py_decref_tmp = (PyObject *)(op); \
if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \
--(_py_decref_tmp)->ob_refcnt != 0) \
_Py_CHECK_REFCNT(_py_decref_tmp) \
else \
_Py_Dealloc(_py_decref_tmp); \
} while (0)