深刻了解 Python 虚拟机：列表（list）的实现原理及源码分析
在本篇文章当中次要给大家介绍 cpython 虚拟机当中针对列表的实现，在 Python 中，List 是一种十分罕用的数据类型，能够存储任何类型的数据，并且反对各种操作，如增加、删除、查找、切片等，在本篇文章当中将深刻去剖析这一点是如何实现的。
列表的构造
在 cpython 实现的 python 虚拟机当中，上面就是 cpython 外部列表实现的源代码：
typedef struct {
PyObject_VAR_HEAD
/* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
PyObject **ob_item;
/* ob_item contains space for 'allocated' elements. The number
* currently in use is ob_size.
* Invariants:
* 0 <= ob_size <= allocated
* len(list) == ob_size
* ob_item == NULL implies ob_size == allocated == 0
* list.sort() temporarily sets allocated to -1 to detect mutations.
*
* Items must normally not be NULL, except during construction when
* the list is not yet visible outside the function that builds it.
*/
Py_ssize_t allocated;
} PyListObject;
#define PyObject_VAR_HEAD PyVarObject ob_base;
typedef struct {
PyObject ob_base;
Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
typedef struct _object {
_PyObject_HEAD_EXTRA // 这个宏定义为空
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
将下面的构造体开展之后，PyListObject 的构造大抵如下所示：
当初来解释一下下面的各个字段的含意：
- Py_ssize_t，一个整型数据类型。
- ob_refcnt，示意对象的援用记数的个数，这个对于垃圾回收很有用途，前面咱们剖析虚拟机中垃圾回收局部在深入分析。
- ob_type，示意这个对象的数据类型是什么，在 python 当中有时候须要对数据的数据类型进行判断比方 isinstance, type 这两个关键字就会应用到这个字段。
- ob_size，这个字段示意这个列表当中有多少个元素。
- ob_item，这是一个指针，指向真正保留 python 对象数据的地址，大抵的内存他们之间大抵的内存布局如下所示：
- allocated，这个示意在进行内存调配的时候，一共调配了多少个 (PyObject *)，实在调配的内存空间为
allocated * sizeof(PyObject *)。
列表操作函数源代码剖析
创立列表
首先须要理解的是在 python 虚拟机外部为列表创立了一个数组，所有的创立的被开释的内存空间，并不会间接进行开释而是会将这些内存空间的首地址保留到这个数组当中，好让下一次申请创立新的列表的时候不须要再申请内存空间，而是间接将之前须要开释的内存间接进行复用即可。
/* Empty list reuse scheme to save calls to malloc and free */
#ifndef PyList_MAXFREELIST
#define PyList_MAXFREELIST 80
#endif
static PyListObject *free_list[PyList_MAXFREELIST];
static int numfree = 0;- free_list，保留被开释的内存空间的首地址。
- numfree，目前 free_list 当中有多少个地址是能够被应用的，事实上是 free_list 前 numfree 个首地址是能够被应用的。
创立链表的代码如下所示（为了精简删除了一些代码只保留外围局部）：
PyObject *
PyList_New(Py_ssize_t size)
{
PyListObject *op;
size_t nbytes;
/* Check for overflow without an actual overflow,
* which can cause compiler to optimise out */
if ((size_t)size > PY_SIZE_MAX / sizeof(PyObject *))
return PyErr_NoMemory();
nbytes = size * sizeof(PyObject *);
// 如果 numfree 不等于 0 那么阐明当初 free_list 有之前应用被开释的内存空间间接应用这部分即可
if (numfree) {
numfree--;
op = free_list[numfree]; // 将对应的首地址返回
_Py_NewReference((PyObject *)op); // 这条语句的含意是将 op 这个对象的 reference count 设置成 1
} else {
// 如果没有闲暇的内存空间 那么就须要申请内存空间 这个函数也会对对象的 reference count 进行初始化 设置成 1
op = PyObject_GC_New(PyListObject, &PyList_Type);
if (op == NULL)
return NULL;
}
/* 上面是申请列表对象当中的 ob_item 申请内存空间，下面只是给列表自身申请内存空间，然而列表当中有许多元素
保留这些元素也是须要内存空间的 上面便是给这些对象申请内存空间
*/
if (size <= 0)
op->ob_item = NULL;
else {op->ob_item = (PyObject **) PyMem_MALLOC(nbytes);
// 如果申请内存空间失败 则报错
if (op->ob_item == NULL) {Py_DECREF(op);
return PyErr_NoMemory();}
// 对元素进行初始化操作 全副赋值成 0
memset(op->ob_item, 0, nbytes);
}
// Py_SIZE 是一个宏
Py_SIZE(op) = size; // 这条语句会被开展成 (PyVarObject*)(ob))->ob_size = size
// 调配数组的元素个数是 size
op->allocated = size;
// 上面这条语句对于垃圾回收比拟重要 次要作用就是将这个列表对象退出到垃圾回收的链表当中
// 前面如果这个对象的 reference count 变成 0 或者其余状况 就能够进行垃圾回收了
_PyObject_GC_TRACK(op);
return (PyObject *) op;
}在 cpython 当中，创立链表的字节码为 BUILD_LIST，咱们能够在文件 ceval.c 当中找到对应的字节码对应的执行步骤：
TARGET(BUILD_LIST) {PyObject *list = PyList_New(oparg);
if (list == NULL)
goto error;
while (--oparg >= 0) {PyObject *item = POP();
PyList_SET_ITEM(list, oparg, item);
}
PUSH(list);
DISPATCH();}从下面 BUILD_LIST 字节码对应的解释步骤能够晓得，在解释执行字节码 BUILD_LIST 的时候的确调用了函数 PyList_New 创立一个新的列表。
列表 append 函数
static PyObject *
// 这个函数的传入参数是列表自身 self 须要 append 的元素为 v
// 也就是将对象 v 退出到列表 self 当中
listappend(PyListObject *self, PyObject *v)
{if (app1(self, v) == 0)
Py_RETURN_NONE;
return NULL;
}
static int
app1(PyListObject *self, PyObject *v)
{// PyList_GET_SIZE(self) 开展之后为 ((PyVarObject*)(self))->ob_size
Py_ssize_t n = PyList_GET_SIZE(self);
assert (v != NULL);
// 如果元素的个数曾经等于容许的最大的元素个数 就报错
if (n == PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"cannot add more objects to list");
return -1;
}
// 上面的函数 list_resize 会保留 ob_item 指向的地位可能包容起码 n+1 个元素（PyObject *）// 如果容量不够就会进行扩容操作
if (list_resize(self, n+1) == -1)
return -1;
// 将对象 v 的 reference count 加一 因为列表当中应用了一次这个对象 所以对象的援用计数须要进行加一操作
Py_INCREF(v);
PyList_SET_ITEM(self, n, v); // 宏开展之后 ((PyListObject *)(op))->ob_item[i] = v
return 0;
}列表的扩容机制
static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
PyObject **items;
size_t new_allocated;
Py_ssize_t allocated = self->allocated;
/* Bypass realloc() when a previous overallocation is large enough
to accommodate the newsize. If the newsize falls lower than half
the allocated size, then proceed with the realloc() to shrink the list.
*/
// 如果列表曾经调配的元素个数大于需要个数 newsize 的就间接返回不须要进行扩容
if (allocated >= newsize && newsize >= (allocated >> 1)) {assert(self->ob_item != NULL || newsize == 0);
Py_SIZE(self) = newsize;
return 0;
}
/* This over-allocates proportional to the list size, making room
* for additional growth. The over-allocation is mild, but is
* enough to give linear-time amortized behavior over a long
* sequence of appends() in the presence of a poorly-performing
* system realloc().
* The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
*/
// 这是外围的数组大小扩容机制 new_allocated 示意新增的数组大小
new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);
/* check for integer overflow */
if (new_allocated > PY_SIZE_MAX - newsize) {PyErr_NoMemory();
return -1;
} else {new_allocated += newsize;}
if (newsize == 0)
new_allocated = 0;
items = self->ob_item;
if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *)))
// PyMem_RESIZE 这是一个宏定义 会申请 new_allocated 个数元素并且将原来数组的元素拷贝到新的数组当中
PyMem_RESIZE(items, PyObject *, new_allocated);
else
items = NULL;
// 如果没有申请到内存 那么报错
if (items == NULL) {PyErr_NoMemory();
return -1;
}
// 更新列表当中的元素数据
self->ob_item = items;
Py_SIZE(self) = newsize;
self->allocated = new_allocated;
return 0;
}在下面的扩容机制下，数组的大小变动大抵如下所示：
$$
newsize \approx size \cdot (size + 1)^{\frac{1}{8}}
$$
列表的插入函数 insert
在列表当中插入一个数据比较简单，只须要将插入地位和其前面的元素往后挪动一个地位即可，整个过程如下所示：
在 cpython 当中列表的插入函数的实现如下所示：
- 参数 op 示意往哪个链表当中插入元素。
- 参数 where 示意在链表的哪个地位插入元素。
- 参数 newitem 示意新插入的元素。
int
PyList_Insert(PyObject *op, Py_ssize_t where, PyObject *newitem)
{
// 查看是否是列表类型
if (!PyList_Check(op)) {PyErr_BadInternalCall();
return -1;
}
// 如果是列表类型则进行插入操作
return ins1((PyListObject *)op, where, newitem);
}
static int
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
{Py_ssize_t i, n = Py_SIZE(self);
PyObject **items;
if (v == NULL) {PyErr_BadInternalCall();
return -1;
}
// 如果列表的元素个数超过限度 则进行报错
if (n == PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"cannot add more objects to list");
return -1;
}
// 确保列表可能包容 n + 1 个元素
if (list_resize(self, n+1) == -1)
return -1;
// 这里是 python 的一个小 trick 就是下标可能有正数的原理
if (where < 0) {
where += n;
if (where < 0)
where = 0;
}
if (where > n)
where = n;
items = self->ob_item;
// 从后往前进行元素的拷贝操作，也就是将插入地位及其之后的元素往后挪动一个地位
for (i = n; --i >= where;)
items[i+1] = items[i];
// 因为链表利用的对象，因而对象的 reference count 须要进行加一操作
Py_INCREF(v);
// 在列表当中保留对象 v
items[where] = v;
return 0;
}列表的删除函数 remove
对于数组 ob_item 来说，删除一个元素就须要将这个元素前面的元素往前挪动，因而整个过程如下所示：
static PyObject *
listremove(PyListObject *self, PyObject *v)
{
Py_ssize_t i;
// 编译数组 ob_item 查找和对象 v 相等的元素并且将其删除
for (i = 0; i < Py_SIZE(self); i++) {int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
if (cmp > 0) {
if (list_ass_slice(self, i, i+1,
(PyObject *)NULL) == 0)
Py_RETURN_NONE;
return NULL;
}
else if (cmp < 0)
return NULL;
}
// 如果没有找到这个元素就进行报错解决 在上面有一个例子从新编译 python 解释器 将这个谬误内容批改的例子
PyErr_SetString(PyExc_ValueError, "list.remove(x): x not in list");
return NULL;
}执行的 python 程序内容为：
data = []
data.remove(1)上面是整个批改内容和报错后果：
从下面的后果咱们能够看到的是，咱们批改的错误信息正确打印了进去。
列表的统计函数 count
这个函数的次要作用就是统计列表 self 当中有多少个元素和 v 相等。
static PyObject *
listcount(PyListObject *self, PyObject *v)
{
Py_ssize_t count = 0;
Py_ssize_t i;
for (i = 0; i < Py_SIZE(self); i++) {int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
// 如果相等则将 count 进行加一操作
if (cmp > 0)
count++;
// 如果呈现谬误就返回 NULL
else if (cmp < 0)
return NULL;
}
// 将一个 Py_ssize_t 的变量变成 python 当中的对象
return PyLong_FromSsize_t(count);
}
列表的拷贝函数 copy
这是列表的浅拷贝函数，它只拷贝了实在 python 对象的指针，并没有拷贝实在的 python 对象，从上面的代码能够晓得列表的拷贝是浅拷贝，当 b 对列表当中的元素进行批改时，列表 a 当中的元素也扭转了。如果须要进行深拷贝能够应用 copy 模块当中的 deepcopy 函数。
>>> a = [1, 2, [3, 4]]
>>> b = a.copy()
>>> b[2][1] = 5
>>> b
[1, 2, [3, 5]]copy 函数对应的源代码（listcopy）如下所示：
static PyObject *
listcopy(PyListObject *self)
{return list_slice(self, 0, Py_SIZE(self));
}
static PyObject *
list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
{// Py_SIZE(a) 返回列表 a 当中元素的个数（留神不是数组的长度 allocated）PyListObject *np;
PyObject **src, **dest;
Py_ssize_t i, len;
if (ilow < 0)
ilow = 0;
else if (ilow > Py_SIZE(a))
ilow = Py_SIZE(a);
if (ihigh < ilow)
ihigh = ilow;
else if (ihigh > Py_SIZE(a))
ihigh = Py_SIZE(a);
len = ihigh - ilow;
np = (PyListObject *) PyList_New(len);
if (np == NULL)
return NULL;
src = a->ob_item + ilow;
dest = np->ob_item;
// 能够看到这里循环拷贝的是指向实在 python 对象的指针 并不是实在的对象
for (i = 0; i < len; i++) {PyObject *v = src[i];
// 同样的因为并没有创立新的对象，然而这个对象被新的列表应用到啦 因而他的 reference count 须要进行加一操作 Py_INCREF(v) 的作用：将对象 v 的 reference count 加一
Py_INCREF(v);
dest[i] = v;
}
return (PyObject *)np;
}下图就是应用 a.copy() 浅拷贝的时候，内存的布局的示意图，能够看到列表指向的对象数组产生了变动，然而数组中元素指向的 python 对象并没有发生变化。
上面是对列表对象进行深拷贝的时候内存的大抵示意图，能够看到数组指向的 python 对象也是不一样的。
列表的清空函数 clear
当咱们在应用 list.clear() 的时候会调用上面这个函数。清空列表须要留神的就是将示意列表当中元素个数的 ob_size 字段设置成 0，同时将列表当中所有的对象的 reference count 设置进行 -1 操作，这个操作是通过宏 Py_XDECREF 实现的，这个宏还会做另外一件事就是如果这个对象的援用计数变成 0 了，那么就会间接开释他的内存。
static PyObject *
listclear(PyListObject *self)
{list_clear(self);
Py_RETURN_NONE;
}
static int
list_clear(PyListObject *a)
{
Py_ssize_t i;
PyObject **item = a->ob_item;
if (item != NULL) {
/* Because XDECREF can recursively invoke operations on
this list, we make it empty first. */
i = Py_SIZE(a);
Py_SIZE(a) = 0;
a->ob_item = NULL;
a->allocated = 0;
while (--i >= 0) {Py_XDECREF(item[i]);
}
PyMem_FREE(item);
}
/* Never fails; the return value can be ignored.
Note that there is no guarantee that the list is actually empty
at this point, because XDECREF may have populated it again! */
return 0;
}列表反转函数 reverse
在 python 当中如果咱们想要反转类表当中的内容的话，就会应用这个函数 reverse。
>>> a = [i for i in range(10)]
>>> a.reverse()
>>> a
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]其对应的源程序如下所示：
static PyObject *
listreverse(PyListObject *self)
{if (Py_SIZE(self) > 1)
reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self));
Py_RETURN_NONE;
}
static void
reverse_slice(PyObject **lo, PyObject **hi)
{assert(lo && hi);
--hi;
while (lo < hi) {
PyObject *t = *lo;
*lo = *hi;
*hi = t;
++lo;
--hi;
}
}下面的源程序还是比拟容易了解的，给 reverse_slice 传递的参数就是保留数据的数组的首尾地址，而后一直的将首尾数据进行替换（其实是替换指针指向的地址）。
总结
本文介绍了 Python 中列表对象的实现细节，介绍了一些罕用函数的实现，包含列表的扩容机制，插入、删除、统计、拷贝、清空和反转等操作的实现形式。
- 列表的扩容机制采纳了一种线性工夫摊销的形式，使得列表的插入操作具备较好的工夫复杂度。
- 列表的插入、删除和统计操作都是通过操作 ob_item 数组实现的，其中插入和删除操作须要挪动数组中的元素。
- 列表的拷贝操作是浅拷贝，须要留神的是进行深拷贝须要应用 copy 模块当中的 deepcopy 函数。
- 列表清空会将 ob_size 字段设置成 0，同时须要将列表当中的所有对象的 reference count 进行 -1 操作，从而防止内存透露。
- 列表的反转操作能够通过替换 ob_item 数组中前后元素的地位实现。
总之，理解 Python 列表对象的实现细节有助于咱们更好地了解 Python 的外部机制，从而编写更高效、更牢靠的 Python 代码。
更多精彩内容合集可拜访我的项目：https://github.com/Chang-LeHung/CSCore
关注公众号：一无是处的钻研僧，理解更多计算机（Java、Python、计算机系统根底、算法与数据结构）常识。