《python解释器源码剖析》第4章--python中的list对象

4.0 序

python中的list对象，底层对应的则是PyListObject。如果你熟悉C++，那么会很容易和C++中的list联系起来。但实际上，这个C++中的list大相径庭，反而和STL中的vector比较类似

4.1 PyListObject对象

我们知道python里面的list对象是支持对元素进行增删改查等操作的，list对象里面存储的，底层无一例外都是PyObject * 指针。所以实际上我们可以这样看待python底层的PyListObject：vector<PyObject *>。

根据我们使用python的list的经验，我们可以得出以下两个结论。

• 每个PyListObject维护的元素个数可以不一样：所以这是一个变长对象
• 可以对PyListObject维护的元素进行添加、删除等操作，所以这是一个可变对象

我们来看一下，PyListObject对象的定义。

typedef struct {
    //不用解释，PyObject加上一个ob_size
    PyObject_VAR_HEAD
    /* ob_item就对应list对象存储的元素，ob_item[0]就是list[0]
       但是我们发现这是一个二级指针，至于这里的二级指针是如何和
       python中list挂上钩的，我们后面会详细介绍
    */
    PyObject **ob_item;
    /*
    这个allocated是什么呢?其实我在最开始的那一章介绍python源码的时候就已经解释过了。
    这里再来说一遍，我们知道PyObject_VAR_HEAD里面有一个ob_size，这是表示变长对象里面
    已经存储了多少个元素了。而这个allocated，则表示最大能存储多少个元素，因为这是一个
    变长对象，因此就意味着可以随时对其进行删除、增加等操作，如果每次添加都要malloc，那么
    效率会非常低下，因此python会事先申请一大份内存，而allocated正是记录了这个一大份内存
    的容量是多少。而ob_size则是目前已经存了多少个，如果你学过golang，你会发现ob_size对应
    golang里面切片的len，而allocated则对应cap。假设一个能容纳10个元素的PyListObject对象
    已经存了5个元素，那么ob_size就是5，allocated就是10。
    从这里我们已经能够看出：
    0 <= ob_size <= allocated
    len(list) == ob_size  注意这里的list指的都是list的实例对象，而不是list这个类本身
    ob_item == NULL 意味着 ob_size == allocated == 0
     */
    Py_ssize_t allocated;
} PyListObject;

刚才说了，python事先会申请一大份内存，这个并不是指在创建的时候申请一大份内存，而是在扩容的时候，会申请更多的内存。

PyListObject有一个resize操作，不用想，这个肯定是修改列表容量的。因为allocated一开始是固定的，但是随着ob_size越来越大，肯定要申请更多的内存，即增大allocated

static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
    //参数self就是PyListObject *对象本身
    //参数newsize就是当前的ob_size
    PyObject **items;
    //既然resize，所以new_allocated就是新的最大容量
    size_t new_allocated, num_allocated_bytes;
    //这里的获取当前PyListObject的allocated
    Py_ssize_t allocated = self->allocated;
	//如果当前的容量大于newsize(ob_size)，并且newsize >= 容量除以2
    //基本上啥也没干直接返回，这一步不需要关心。
    //因为执行这一步表示内存不需要重新分配
    if (allocated >= newsize && newsize >= (allocated >> 1)) {
        assert(self->ob_item != NULL || newsize == 0);
        Py_SIZE(self) = newsize;
        return 0;
    }
    /*
    计算重新分配的内存的大小
    这一步很重要，新分配的容量就等于newsize + newsize >> 3 + 3 if newsize < 9 else 6
     */
    new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6);
    if (new_allocated > (size_t)PY_SSIZE_T_MAX / sizeof(PyObject *)) {
        PyErr_NoMemory();
        return -1;
    }
    //如果新的ob_size是0，那么新分配的容量也是0
    if (newsize == 0)
        new_allocated = 0;
    //所占的字节，就是new_allocated * sizeof(PyObject *)
    //但是我们发现这里乘上的是一个指针的大小，这是一个很关键的问题，我们后面会详谈
    num_allocated_bytes = new_allocated * sizeof(PyObject *);
    //为ob_item申请内存
    items = (PyObject **)PyMem_Realloc(self->ob_item, num_allocated_bytes);
    if (items == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    //指向新的内存块，扩展列表。
    self->ob_item = items;
    //将ob_size变为newsize
    Py_SIZE(self) = newsize;
    //将allocated变为新的new_allocated
    self->allocated = new_allocated;
    return 0;
}

我们来刚才说，python中的list申请容量是按照new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6)这样的规则来的，我们来看看。

allocated = 0
print(allocated, end=" ")
for size in range(100):
    if allocated < size:
        allocated = size + (size >> 3) + (3 if size < 9 else 6)
        print(allocated, end=" ")  # 0 4 8 16 25 35 46 58 72 88 106

我们具体来计算一下。

l = []
allocated = 0
print(allocated, end=" ")
for _ in range(100):
    l.append(_)
    if len(l) > allocated:
        # 从变量名也能看出，这获取的是容量，但是为什么要除以8呢？
        # 因为[]里面的每一个元素占8个字节啊，咦，那列表里面存"xx" * 1000，这也占8个字节？
        # 没错，是的，关于为什么我们会后面说。
        # 同时这也引出了一个问题：为什么python中list对象在支持存储不同类型数据的前提下，还能保证查询的时间复杂度是O(1)呢？
        # 先保留这些疑问，后面会解答
        allocated = (l.__sizeof__() - [].__sizeof__()) // 8
        print(allocated, end=" ")  # 0 4 8 16 25 35 46 58 72 88 106

可以看到我们计算的结果和官方源码给的是一样的，其实这是废话，python解释器就是按照官方源码写的。但还有一个特殊情况：

l = [1, 2, 3, 4, 5]
print((l.__sizeof__() - [].__sizeof__()) // 8)  # 5
"""
结果是5，我们在之前的结果并没有看见5啊。这是因为对于初始化一个列表时，有多少元素，容量就是多少，此时allocated和ob_size是相等的
"""
l.append(6)
"""
什么时候会扩容呢？是当我们往列表进行append的时候，解释器发现容量不够。
比如此时上面的ob_size和allocated都是5，但是当append一个6的时候，解释器发现容量不够了
ob_size已经超过allocated了，于是才会扩容。按照 newsize + (newsize >> 3) + (if newsize < 9 ? 3 : 6)
"""
# 此时扩容的结果就是9，尽管里面只存储的了6个元素，但是人家内存已经分配了
# 所以计算的就是9个元素的内存，那么除以8，得到的就是9，即分配的内存能够容纳9个元素
print((l.__sizeof__() - [].__sizeof__()) // 8)  # 9

在这里还想问一句，对于初始化一个列表，你认为l = []和l = list()哪个速度更快呢？首先这两者你print之后得到的都是一个[]

答案是l = []更快，因为python中的list在C语言的层面可以看做是allocated-array：过分配数组，直接使用的是底层C语言的数据结构。而l = list()相当于是python层面上的一个函数调用，既然调用肯定要创建栈帧、记录函数参数等等，会进行额外的资源消耗。

为什么list通过索引查找元素的时间复杂度是O(1)

我们之前说了，其实不说大家也知道，python里面列表通过索引定位元素的时间复杂度是O(1)，可是列表里面存放的元素大小不一，是怎么做到的呢？还记的我们之前说，列表里面存储的元素都占8个字节吗？我们再来验证一下。

import sys
l = ["a" * 1000, "b" * 1000]
print(sys.getsizeof(l) - sys.getsizeof([]))  # 16
print(sys.getsizeof(l[0]) - sys.getsizeof(""))  # 1000
"""
由于python中的对象除了值本身，还有其他的信息
比如引用计数、ob_size等等，这些都是要占内存的。
我们把这些值减掉，比如列表的话减去一个[]，字符串减去一个""，
把共同具有的那些特征那么所占的内存去掉，那么剩下来的就是值本身占的内存
"""

可以看到，加上本身的信息，l[0]占了不止1000个字节，同理l[1]也是，但是我们计算列表的时候，发现里面的值只占了16个字节，说明每一个值占了8个字节。其实任何一个对象存在列表里面都是8个字节，而我们看PyListObject的定义，里面有一个PyObject **ob_item，因此很容易猜到，python的list里面存储的实际上是指针。其实这个ob_item是一个指向指针数组的指针，这个指针指向了指针数组的首地址。因此我们可以看到，python的list、tuple，实际是哪个都是采用了元素外置的方法，元素的实际的值都存储在堆上，至于列表本身，存储的不过是这些元素的内存指针。不管你值本身占的内存有多大，但是内存地址是固定的，在64位机器上是8个字节。通过索引可以瞬间计算出指针的偏移量，从而找到对应元素的指针，打印的时候会自动打印指针所指向的内存。索引我们使用id(l[0])查看第一个元素的内存地址时，会打印一串数字，也就是内存地址，但是实际上l[0]在python的底层中，存储的就是地址。我们打印的时候，打印的也是指针，只不过我们没有权限操作指针，能有权限操作指针的只有解释器，因此当我们打印会自动打印指针的指向内存，我们可以认为尽管存储的是指针，但是最终操作的都是指针指向的内存。

4.2 PyListObject对象的创建与维护

4.2.1 创建对象

为了创建一个列表，python底层只提供了唯一的一条途径--PyList_New。这个函数接收一个size参数，从而允许我们在创建一个PyListObject对象时指定元素个数。这里仅仅是指定了元素个数，却没有指定元素是什么，我们来看看创建PyListObject对象的过程

PyObject *
PyList_New(Py_ssize_t size)
{
    //声明一个PyListObject *对象
    PyListObject *op;
#ifdef SHOW_ALLOC_COUNT
    static int initialized = 0;
    if (!initialized) {
        Py_AtExit(show_alloc);
        initialized = 1;
    }
#endif
    //如果size小于0，直接抛异常
    if (size < 0) {
        PyErr_BadInternalCall();
        return NULL;
    }
    //缓冲池是否可用，如果可用
    if (numfree) {
        //直接使用缓冲池的空间
        numfree--;
        op = free_list[numfree];
        _Py_NewReference((PyObject *)op);
#ifdef SHOW_ALLOC_COUNT
        count_reuse++;
#endif
    } else {
        //不可用的时候，申请内存
        op = PyObject_GC_New(PyListObject, &PyList_Type);
        if (op == NULL)
            return NULL;
#ifdef SHOW_ALLOC_COUNT
        count_alloc++;
#endif
    }
    //如果size小于0，ob_item设置为NULL
    if (size <= 0)
        op->ob_item = NULL;
    else {
        //否则的话，为维护的列表申请空间
        op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
        if (op->ob_item == NULL) {
            Py_DECREF(op);
            return PyErr_NoMemory();
        }
    }
    //设置ob_size和allocated，然后返回op
    Py_SIZE(op) = size;
    op->allocated = size;
    _PyObject_GC_TRACK(op);
    return (PyObject *) op;
}

通过源码我们可以看到，python在创建列表的时候，底层实际上是分为两部分的，一部分是创建PyListObject对象，另一部分是PyListObject对象所维护的列表，这是两块分离的内存，它们通过ob_item建立了联系。咦，有人会问，维护的列表不是PyListObject结构体的一个属性吗？是的，在这里PyListObject指的是不包含其维护列表的PyListObject，当然有时我们也用PyListObject专门只指其维护的列表、或者我们有时也说PyListObject所维护的列表等等，这些说法不用刻意区分，通过上下文是可以理解的。

我们注意到源码里面有一个缓冲池，是的，创建PyListObject对象时，会先检测缓冲池free_lists里面是否有可用的对象，有的话直接拿来用，否则通过malloc在系统堆上申请。缓冲池中最多维护80个PyListObject对象。

/* 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 void
list_dealloc(PyListObject *op)
{
    Py_ssize_t i;
    PyObject_GC_UnTrack(op);
    Py_TRASHCAN_SAFE_BEGIN(op)
    if (op->ob_item != NULL) {
        /* Do it backwards, for Christian Tismer.
           There's a simple test case where somehow this reduces
           thrashing when a *very* large list is created and
           immediately deleted. */
        i = Py_SIZE(op);
        //释放list中的每一个元素
        while (--i >= 0) {
            Py_XDECREF(op->ob_item[i]);
        }
        PyMem_FREE(op->ob_item);
    }
    //然后判断缓冲池里面PyListObject对象的个数，如果没满，就添加到缓冲池，
    if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
        free_list[numfree++] = op;
    else
        Py_TYPE(op)->tp_free((PyObject *)op);
    Py_TRASHCAN_SAFE_END(op)
}

4.2.2 添加元素

在第一个PyListObject创建时，显然numfree是0，不会走缓冲池，而是直接在堆上申请，假设我们申请创建有6个元素的PyListObject对象，那么会调用PyList_New(6)来创建PyListObject对象，在对象完成之后，第一个PyListObject对象就完成了。

通过上图，我们可以抛出一个问题。

import pandas as pd
# 具有6个元素的列表
l = [1, "xx", int, {}, pd, ()]
print(l.__sizeof__())  # 88
print([].__sizeof__())  # 40
"""
两者相减得到48,6个元素，每个指针正好8字节。
"""

我们看到元素外置、存储指针，6个元素总共用了48个字节，但是剩下的40个字节是哪来的。还记得吗？python中的对象在底层都是一个结构体实例，我们计算的可以不仅仅是维护的值，还有其他的信息啊。首先从图中可以看出，ob_refcnt:引用计数，占八个字节、ob_type：PyTypeObject对象的一个指针，八个字节、ob_size：容纳元素的个数，八个字节、ob_item：这是一个二级指针，指向了指针数组的指针，八个字节、allocated：容量，八个字节，正好40个字节，再加上ob_item指向的指针数组里面有6和元素，再加上6*8=48，正好88个字节。

然后我们看看PyListObject对象是如何设置元素的。

int
PyList_SetItem(PyObject *op, Py_ssize_t i,
               PyObject *newitem)
{	//参数为：PyObject *、索引、值
 	//一个二级指针
    PyObject **p;
    //类型检查
    if (!PyList_Check(op)) {
        Py_XDECREF(newitem);
        PyErr_BadInternalCall();
        return -1;
    }
    //索引检查
    if (i < 0 || i >= Py_SIZE(op)) {
        Py_XDECREF(newitem);
        PyErr_SetString(PyExc_IndexError,
                        "list assignment index out of range");
        return -1;
    }
    //ob_item表示数组的首地址
    //ob_item + i直接获取数组中索引为i的元素的指针
    //当然数组里面存储的本身也是一个指针，所以这里的p是一个二级指针
    p = ((PyListObject *)op) -> ob_item + i;
    //直接将*p，也就是数组中索引为i的指针(一级)指向的元素设置为newitem
    Py_XSETREF(*p, newitem);
    return 0;
}

假设我们设置l[2]=100的话，那么

4.2.3 插入元素

设置元素和和插入元素是不同的，设置元素不会导致ob_item指向的内存发生改变，而插入元素可能会导致ob_item指向的内存发生变化

int
PyList_Insert(PyObject *op, Py_ssize_t where, PyObject *newitem)
{
    //类型检查
    if (!PyList_Check(op)) {
        PyErr_BadInternalCall();
        return -1;
    }
    //底层又调用ins1
    return ins1((PyListObject *)op, where, newitem);
}
static int
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
{
    /*参数self：PyListObject *
    参数where：索引
    参数v：插入的值，这是一个PyObject *指针，因为list里面存的都是指针
    */
    //i:后面for循环遍历用的，n则是当前列表的元素个数
    Py_ssize_t i, n = Py_SIZE(self);
    //指向指针数组的二级指针
    PyObject **items;
    //如果v是NULL，错误的内部调用
    if (v == NULL) {
        PyErr_BadInternalCall();
        return -1;
    }
    //列表的元素个数不可能无限增大，一般当你还没创建到PY_SSIZE_T_MAX个对象时
    //你内存就已经玩完了，但是python仍然做了检测当达到这个PY_SSIZE_T_MAX时，会报出内存溢出错误
    if (n == PY_SSIZE_T_MAX) {
        PyErr_SetString(PyExc_OverflowError,
            "cannot add more objects to list");
        return -1;
    }
    //调整列表容量，既然要inert，那么就势必要多出一个元素
    //这个元素还没有设置进去，但是先把这个坑给留出来
    //当然如果容量够的话，是不会扩容的，只有当容量不够的时候才会扩容
    if (list_resize(self, n+1) < 0)
        return -1;
    //确定插入点
    //这里可以看到如果where小于0，那么我们就加上n，也就是当前列表的元素个数
    //比如有6个元素，那么我们where=-1，加上6，就是5，显然就是insert在最后一个索引的位置上
    if (where < 0) {
        where += n;
        //如果吃撑了，写个-100，加上元素的个数还是小于0
        if (where < 0)
            //那么where=0，就在开头插入
            where = 0;
    }
    //如果where > n，那么就索引为n的位置插入，
    //可元素个数为n，最大索引是n-1啊，对，所以此时就相当于append
    if (where > n)
        where = n;
    //拿到原来的二级指针，指向一个指针数组
    items = self->ob_item;
    //然后让不断遍历，把索引为i的值赋值给索引为i+1，既然是在where处插入
    //那么where之前的就不需要动了，到where处就停止了
    for (i = n; --i >= where; )
        items[i+1] = items[i];
    //增加引用计数，因为它作为列表的一个元素了
    Py_INCREF(v);
    //将where处的值设置成v，还记得这个v吗？对，没错，这是一个PyObject *指针
    //打印的话，会打印*v
    items[where] = v;
    return 0;
}

所以可以看到，python插入数据是非常灵活的。不管你在什么位置插入，都是合法的。因为它会自己调整位置，在确定位置之后，会将当前位置以及之后的所有元素向后挪动一个位置，空出来的地方设置为插入的值。因此熟悉C++的话，会发现这和vector是非常类似的，但是和C++中的list确实大相径庭的，尽管名字一样。

既然插入元素，那么自然少不了append直接往尾部追加元素了。这个就比较简单了，就相当于insert的where>n，直接将索引为n的地方设置为append的值即可。这里就不看源码了，比较简单。只是如果容量够的话，是不需要重新分配空间的。

4.2.4 删除元素

删除元素，对于python的列表来说，直接调用l.remove即可

l = [1, 1, 2, 3]
l.remove(1)
print(l)  # [1, 2, 3]
# 会自动删除第一个出现的元素

那么底层是如何实现的呢？

static PyObject *
list_remove(PyListObject *self, PyObject *value)
{
    //删除值，对于底层来说，就是删除数组中值对应的指针。
    //所以value仍然是PyObject *类型
    //i，for循环遍历用的
    Py_ssize_t i;
    //从0开始，直到不小于ob_size
    for (i = 0; i < Py_SIZE(self); i++) {
        //将指针数组里面的每一个元素和value进行比较
        int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);
        //如果cmp大于0，表示元素和value匹配
        if (cmp > 0) {
            //调用list_ass_slice将其删除
            if (list_ass_slice(self, i, i+1,
                               (PyObject *)NULL) == 0)
                Py_RETURN_NONE;
            return NULL;
        }
        else if (cmp < 0)
            return NULL;
    }
    //否则报错，x不再list中。
    PyErr_SetString(PyExc_ValueError, "list.remove(x): x not in list");
    return NULL;
}
//另外这个list_ass_slice其实起到的是替换的作用，只不过也可以充当删除
//从源码中可以看出把i: i+1部分的元素给删了
/*
l = [1, 2, 3, 4]
l[0: 1] = []
print(l)  # [2, 3, 4]
*/

既然是删除，那么和insert一样。全局都会进行移动，比如我把第一个元素删了，那么第二个元素要顶在第一个元素的位置，第n个元素要顶在第n-1个元素的位置上。

4.3 PyListObject对象缓冲池

还记的我们之前说的缓冲池free_lists吗？是用来缓冲PyListObject对象的，但是现在问题来了，这些缓冲的PyListObject对象从哪里获取的呢？或者说是何时创建的呢？答案其实一开始就说了，是在一个PyListObject对象销毁的时候创建的。

static void
list_dealloc(PyListObject *op)
{
    //遍历用的
    Py_ssize_t i;
    PyObject_GC_UnTrack(op);
    Py_TRASHCAN_SAFE_BEGIN(op)
    //改变每一个元素的引用计数
    //销毁PyListObject对象维护的元素列表
    if (op->ob_item != NULL) {
        /* Do it backwards, for Christian Tismer.
           There's a simple test case where somehow this reduces
           thrashing when a *very* large list is created and
           immediately deleted. */
        i = Py_SIZE(op);
        while (--i >= 0) {
            Py_XDECREF(op->ob_item[i]);
        }
        PyMem_FREE(op->ob_item);
    }
    //如果缓冲池未满，那么放回到缓冲池当中
    if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
        free_list[numfree++] = op;
    else
        Py_TYPE(op)->tp_free((PyObject *)op);
    Py_TRASHCAN_SAFE_END(op)
}

我们知道在创建一个新的PyListObject对象时，实际上是分为两步的，先创建PyListObject，然后创建其维护的元素列表。同理，在销毁一个PyListObject对象时，先销毁销毁维护的元素列表，然后再释放PyListObject对象自身

现在可以很清晰地明白了，原本空荡荡的缓冲池其实是被已经死去的PyListObject对象填充了，在以后创建新的PyListObject对象时，python会首先唤醒这些死去的PyListObject对象，给它们一个洗心革面、重新做人的机会。但注意的是，这里的缓冲仅仅是PyListObject对象，对于其维护的列表，已经不再指向了，引用减少，那么这些元素就大难临头各自飞了，或生存、或毁灭，不再被对应的PyListObject的那个指针所束缚。但是为什么要这么做呢？可以想一下，如果继续维护的，那么很可能会产生悬空指针的问题，因此这些元素所占的空间必须交还给系统(前提是没有指针指向了)

但是实际上，是可以将PyListObject对象维护的元素列表保留的，即只调整引用计数，并将元素都设置为NULL，但是并不释放内存空间。因此这样一来，释放的内存不会交给系统堆，那么再次分配的时候，速度会快很多。但是这样带一个问题就是，这些内存没人用也会一直占着，并且只能供PyListObject对象使用，因此python还是为避免消耗过多内存，采取将元素列表的内存交换给了系统堆这样的做法，在时间和空间上选择了空间。

我们之前的PyListObject对象的示意图，如果在缓冲池当中应该变成什么样子呢？

在下一次创建新的list对象时，这个PyListObject对象将会被重新唤醒，重新分配元素列表所占的内存，重新拥抱新的元素列表。正如我，就喜欢纸片人，不停地换老婆，每当出现新的动漫，就会拥抱新的纸片人。