ESON

Daily Notes

0%

Python 对象初探

发表于 分类于 ， ， ， ， ，
本文字数： 7.2k 阅读时长 ≈ 7 分钟

Python 对象初探

在 Python 的世界一切皆对象，不论是整数，还是字符串，甚至连类型、函数等都是一种对象。

对象的分类

以下是 Python 对象的大致的一个分类

  • Fundamental 对象: 类型对象
  • Numeric 对象: 数值对象
  • Sequence 对象: 容纳其他对象的序列集合对象
  • Mapping 对象: 类似 C++中的 map 的关联对象
  • Internal 对象: Python 虚拟机在运行时内部使用的对象

object category

对象机制的基石 PyObject

对于初学者来说这么多类型的对象怎么学？别着急，我们后续章节会解答。

在开始我们的学习之旅之前，我们要先认识一个结构体PyObject，可以说 Python 的对象机制就是基于PyObject拓展开来的，所以我们先看看PyObject 到底长什么样。

源文件：Include/object.h

1
2
3
4
5
6
7
8
9
10
// 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;

经过宏替换后

1
2
3
4
5
6
7
8
typedef struct _object {
    // _PyObject_HEAD_EXTRA  双向链表，垃圾回收需要用到
    struct _object *_ob_next;
    struct _object *_ob_prev;

    Py_ssize_t ob_refcnt;         // 引用计数
    struct _typeobject *ob_type;  // 类型指针，指向类型对象，决定了对象的类型
} PyObject;

Python 中的所有对象都拥有一些相同的内容，而这些内容就定义在PyObject中，

PyObject 包含 一个用于垃圾回收的双向链表，一个引用计数变量 ob_refcnt 和 一个类型对象指针ob_type

引用计数表示该对象被变量引用的次数，对象被引用1次，ob_refcnt就会加1，引用解除时，ob_refcnt就会减少1。引用计数是Python实现对象回收的重要机制之一。

PyObject

定长对象与变长对象

Python中根据对象所占用的内存空间大小是否固定，可以将对象分为定长对象和变长对象。
定长对象如整数。变长对象如字符串、列表等。字符串、列表中有多少个元素，都无法事先确定，只能使用变长对象来进行存储。

变长对象都拥有一个相同的内容 PyVarObject，而 PyVarObject也是基于PyObject扩展的。

从代码中可以看出PyVarObject比PyObject多出了一个用于存储元素个数的变量ob_size。

源文件：Include/object.h

1
2
3
4
5
// Include/object.h
typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

宏替换后

1

PyVarObject

类型对象

前面我们提到了PyObject 的 对象类型指针struct _typeobject *ob_type，它指向的类型对象就决定了一个对象是什么类型的。

这是一个非常重要的结构体，它不仅仅决定了一个对象的类型，还包含大量的元信息，
包括创建对象需要分配多少内存，对象都支持哪些操作等等。

接下来我们看一下struct _typeobject代码

在 PyTypeObject 的定义中包含许多信息，主要分类以下几类:

  • 类型名, tp_name, 主要用于 Python 内部调试用
  • 创建该类型对象时分配的空间大小信息，即 tp_basicsize 和 tp_itemsize
  • 与该类型对象相关的操作信息(如 tp_print 这样的函数指针)
  • 一些对象属性

源文件：Include/object.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 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

1
2
// Include/object.h
#define PyObject_VAR_HEAD      PyVarObject ob_base;

对象的类型是由该对象指向的 类型对象 决定的，那么类型对象的类型是由谁决定的呢？
对于其他对象，可以通过与其关联的类型对象确定其类型，那么通过什么来确定一个对象是类型对象呢？
答案就是 PyType_Type

源文件：Objects/typeobject.c

1
2
3
4
5
6
7
8
9
// 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

1
2
3
4
5
6
7
8
9
10
// 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

1
2
3
4
5
6
7
8
9
10
// 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。创建一个整数对象的方式

1
PyObject* longobj = PyObject_New(Pyobject, &PyLong_Type);

与类型相关的 API 或称为 COL (Concrete Object Layer)

这类 API 通常只能作用于某一种类型的对象上，对于每一种内建对象
Python 都提供了这样一组 API。例如整数对象，我们可以利用如下的 API 创建

1
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

1
2
3
4
5
6
7
8
9
// 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.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 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 函数

1
2
3
4
5
6
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

1
2
3
4
5
6
7
8
9
10
// 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

1
2
3
4
5
6
7
8
9
10
11
// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 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)