解密列表的创建与销毁，以及缓存池长什么样子？

//Objects/listobject.c
PyObject *
PyList_New(Py_ssize_t size)
{   
    // 声明一个 PyListObject * 变量
    // 指向即将创建的 PyListObject 对象
    PyListObject *op;
    // 底层数组的长度必须大于等于 0
    if (size < 0) {
        PyErr_BadInternalCall();
        return NULL;
    }
    
    // PyList_MAXFREELIST 是一个宏，表示缓存池的容量
    // 编译时可以选择是否禁用缓存池，默认不禁用，容量为 80
#if PyList_MAXFREELIST > 0
    // 获取进程状态对象内部的缓存池
    struct _Py_list_state *state = get_list_state();
    // state->numfree 表示缓存池中已缓存的元素个数
    // 如果大于 0，证明有可用元素，那么会从缓存池中获取
    if (PyList_MAXFREELIST && state->numfree) {
        // 可用元素的数量减一
        state->numfree--;
        // 获取缓存的列表指针，并将指向的列表的引用计数设置为 1
        op = state->free_list[state->numfree];
        OBJECT_STAT_INC(from_freelist);
        _Py_NewReference((PyObject *)op);
    }
    else
#endif
    {
        // 如果缓存池被禁用，或者缓存池中没有可用元素
        // 那么通过 PyObject_GC_New 申请内存
        // 问题来了，之前申请内存不是用的 PyObject_New 吗
        // 这里为啥换成 PyObject_GC_New 呢？我们稍后再说
        op = PyObject_GC_New(PyListObject, &PyList_Type);
        if (op == NULL) {
            return NULL;
        }
    }
    // 如果 size <= 0，那么一定等于 0，此时列表不包含任何元素
    if (size <= 0) {
        // 那么 ob_item 直接设置为 NULL
        op->ob_item = NULL;
    }
    else {
        // 否则为底层数组申请内存，因为存储的都是指针
        // 所以大小为 size * sizeof(PyObject *)
        op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
        if (op->ob_item == NULL) {
            Py_DECREF(op);
            return PyErr_NoMemory();
        }
    }
    // 将 ob_size 和 allocated 均设置为 size
    Py_SET_SIZE(op, size);
    op->allocated = size;
    // 让列表被 GC 跟踪
    _PyObject_GC_TRACK(op);
    // 转成泛型指针之后返回
    return (PyObject *) op;
}

import sys
lst = []
# 可以调用 __sizeof__ 方法计算对象的内存
print(lst.__sizeof__())  # 40
# 也可以通过 sys.getsizeof 函数
print(sys.getsizeof(lst))  # 56

import sys
print("".__sizeof__())  # 49
print(sys.getsizeof(""))  # 49
print((123).__sizeof__())  # 28
print(sys.getsizeof(123))  # 28

// Include/internal/pycore_list.h
#define PyList_MAXFREELIST 80
struct _Py_list_state {
#if PyList_MAXFREELIST > 0
    // free_list 是一个 PyListObject * 数组，容量为 80
    // 添加元素时会从数组的尾部添加
    // 获取元素时也会从数组的尾部获取
    PyListObject *free_list[PyList_MAXFREELIST];
    // 缓存池中可用元素数量
    int numfree;
#endif
};
// Objects/listobject.c
static struct _Py_list_state *
get_list_state(void)
{   
    // 列表缓存池会在解释器启动时创建好，并放在进程状态对象中
    PyInterpreterState *interp = _PyInterpreterState_GET();
    // 返回 struct _Py_list_state 实例
    return &interp->list;
}

// Objects/listobject.c
static void
list_dealloc(PyListObject *op)
{
    Py_ssize_t i;
    // 列表可能会产生循环引用，因此创建之后要被 GC 跟踪
    // 而现在要被回收了，所以也要取消 GC 跟踪
    PyObject_GC_UnTrack(op);
    // 这一步的作用，稍后再说
    Py_TRASHCAN_BEGIN(op, list_dealloc)
    // 先释放底层数组
    if (op->ob_item != NULL) {
        // 但是释放之前，还有一件重要的事情
        // 要将底层数组中每个指针指向的对象的引用计数都减去 1
        // 因为它们不再持有对"对象"的引用
        i = Py_SIZE(op);
        while (--i >= 0) {
            Py_XDECREF(op->ob_item[i]);
        }
        // 然后释放底层数组所占的内存
        PyMem_Free(op->ob_item);
    }
#if PyList_MAXFREELIST > 0
    // 获取缓存池
    struct _Py_list_state *state = get_list_state();
    // 如果已缓存的元素小于 80 个，并且 op 指向的是列表
    // 那么将 op 追加到数组中，并将 numfree 自增 1
    if (state->numfree < PyList_MAXFREELIST && PyList_CheckExact(op)) {
        state->free_list[state->numfree++] = op;
        OBJECT_STAT_INC(to_freelist);
    }
    else
#endif
    {
        // 否则将列表的内存释放掉
        Py_TYPE(op)->tp_free((PyObject *)op);
    }
    Py_TRASHCAN_END
}

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

L = None
for i in range(2 ** 20):
    L = [L]
del L