Python列表创建与销毁及缓存池机制深度解析

阿澈

发布时间：2026-10-15 | 5人浏览过

原创

本文深入解析Python列表的底层实现，重点阐述PyList_New创建流程与list_dealloc销毁逻辑。通过解析源码揭示列表缓存池（free_list）如何复用PyListObject对象，同时释放底层数组以平衡时间与空间开销。

列表的创建

在Python底层，列表的创建仅依赖唯一的C API函数PyList_New。该函数接收一个size参数，用于指定底层PyObject *数组的长度，从而在实例化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) {
        //将缓存池内对象个数减1
        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 {
        //否则的话，创建一个指定容量的指针数组，然后让ob_item指向它
        //所以是先创建PyListObject对象, 然后创建指针数组
        //最后通过ob_item建立联系
        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对象时，Python会优先检查缓存池free_list中是否存在可用对象。若存在，则直接复用；若不存在，则通过malloc在系统堆上申请新内存。该缓存池基于数组实现，最大可维护80个PyListObject对象。

#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) {
        i = Py_SIZE(op);
        //但是释放之前，还有一件重要的事情
        //要将底层数组中每个指针指向的对象的引用计数都减去1
        //因为它们不再持有对"对象"的引用
        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
        //否则的话就释放掉PyListObject对象所占的内存
        Py_TYPE(op)->tp_free((PyObject *)op);
    Py_TRASHCAN_SAFE_END(op)
}

创建新的PyListObject对象实际上包含两个步骤：首先实例化PyListObject对象本身，随后创建底层数组，最后将PyListObject对象中的ob_item成员指向该底层数组。

与之对应，销毁PyListObject对象时，首先需销毁由ob_item维护的底层数组，随后释放PyListObject对象自身（前提是缓存池未满）。

由此可见，缓存池中存放的实际上是已销毁的PyListObject对象。在后续创建新列表时，Python会优先唤醒这些“死”对象，赋予其重新使用的机会。需要注意的是，缓存的仅是PyListObject对象本身，其ob_item成员已不再指向原有的底层数组。

从list_dealloc函数可见，PyListObject对象在放入缓存池前，其ob_item指向的数组已被释放，且数组中各指针指向对象的引用计数减1。这意味着这些指针指向的对象与PyListObject之间的关联彻底切断，它们可能继续存在或被销毁，但不再受该列表对象管理。

为何不连同底层数组一起缓存？若保留底层数组及其指针指向的对象，这些对象将永远无法被释放，极易导致悬空指针问题。因此，必须将这些指针指向的对象所占空间交还系统（前提是无其他引用）。

实际上，可以保留PyListObject对象维护的底层数组。具体做法是：仅将数组中指针指向对象的引用计数减1，并将数组指针置为NULL，不再指向原对象，但不释放底层数组本身的内存空间。

若采用上述保留数组的做法，再次分配时速度会显著提升，但代价是这些内存将被独占且无法用于其他用途。为避免过度消耗内存，Python选择在时间和空间之间优先保障空间效率，即将底层数组所占内存交还系统堆。

lst1 = [1, 2, 3]
print(id(lst1))  # 1243303086208
# 扔到缓存池中，放在数组的尾部
del lst1
# 从缓存池中获取，也会从数组的尾部开始拿
lst2 = [1, 2, 3]
print(id(lst2))  # 1243303086208
# 因此打印的地址是一样的