//Objects/listobject.c
PyObject *
PyList_New(Py_ssize_t size)
{   
    // 聲明一個 PyListObject * 變量
    // 指向即將創(chuàng)建的 PyListObject 對象
    PyListObject *op;
    // 底層數(shù)組的長度必須大于等于 0
    if (size < 0) {
        PyErr_BadInternalCall();
        return NULL;
    }
    
    // PyList_MAXFREELIST 是一個宏，表示緩存池的容量
    // 編譯時可以選擇是否禁用緩存池，默認不禁用，容量為 80
#if PyList_MAXFREELIST > 0
    // 獲取進程狀態(tài)對象內(nèi)部的緩存池
    struct _Py_list_state *state = get_list_state();
    // state->numfree 表示緩存池中已緩存的元素個數(shù)
    // 如果大于 0，證明有可用元素，那么會從緩存池中獲取
    if (PyList_MAXFREELIST && state->numfree) {
        // 可用元素的數(shù)量減一
        state->numfree--;
        // 獲取緩存的列表指針，并將指向的列表的引用計數(shù)設(shè)置為 1
        op = state->free_list[state->numfree];
        OBJECT_STAT_INC(from_freelist);
        _Py_NewReference((PyObject *)op);
    }
    else
#endif
    {
        // 如果緩存池被禁用，或者緩存池中沒有可用元素
        // 那么通過 PyObject_GC_New 申請內(nèi)存
        // 問題來了，之前申請內(nèi)存不是用的 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 直接設(shè)置為 NULL
        op->ob_item = NULL;
    }
    else {
        // 否則為底層數(shù)組申請內(nèi)存，因為存儲的都是指針
        // 所以大小為 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 均設(shè)置為 size
    Py_SET_SIZE(op, size);
    op->allocated = size;
    // 讓列表被 GC 跟蹤
    _PyObject_GC_TRACK(op);
    // 轉(zhuǎn)成泛型指針之后返回
    return (PyObject *) op;
}

import sys

lst = []
# 可以調(diào)用 __sizeof__ 方法計算對象的內(nèi)存
print(lst.__sizeof__())  # 40
# 也可以通過 sys.getsizeof 函數(shù)
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 * 數(shù)組，容量為 80
    // 添加元素時會從數(shù)組的尾部添加
    // 獲取元素時也會從數(shù)組的尾部獲取
    PyListObject *free_list[PyList_MAXFREELIST];
    // 緩存池中可用元素數(shù)量
    int numfree;
#endif
};

// Objects/listobject.c
static struct _Py_list_state *
get_list_state(void)
{   
    // 列表緩存池會在解釋器啟動時創(chuàng)建好，并放在進程狀態(tài)對象中
    PyInterpreterState *interp = _PyInterpreterState_GET();
    // 返回 struct _Py_list_state 實例
    return &interp->list;
}

// Objects/listobject.c
static void
list_dealloc(PyListObject *op)
{
    Py_ssize_t i;
    // 列表可能會產(chǎn)生循環(huán)引用，因此創(chuàng)建之后要被 GC 跟蹤
    // 而現(xiàn)在要被回收了，所以也要取消 GC 跟蹤
    PyObject_GC_UnTrack(op);
    // 這一步的作用，稍后再說
    Py_TRASHCAN_BEGIN(op, list_dealloc)
    // 先釋放底層數(shù)組
    if (op->ob_item != NULL) {
        // 但是釋放之前，還有一件重要的事情
        // 要將底層數(shù)組中每個指針指向的對象的引用計數(shù)都減去 1
        // 因為它們不再持有對"對象"的引用
        i = Py_SIZE(op);
        while (--i >= 0) {
            Py_XDECREF(op->ob_item[i]);
        }
        // 然后釋放底層數(shù)組所占的內(nèi)存
        PyMem_Free(op->ob_item);
    }
#if PyList_MAXFREELIST > 0
    // 獲取緩存池
    struct _Py_list_state *state = get_list_state();
    // 如果已緩存的元素小于 80 個，并且 op 指向的是列表
    // 那么將 op 追加到數(shù)組中，并將 numfree 自增 1
    if (state->numfree < PyList_MAXFREELIST && PyList_CheckExact(op)) {
        state->free_list[state->numfree++] = op;
        OBJECT_STAT_INC(to_freelist);
    }
    else
#endif
    {
        // 否則將列表的內(nèi)存釋放掉
        Py_TYPE(op)->tp_free((PyObject *)op);
    }
    Py_TRASHCAN_END
}

lst1 = [1, 2, 3]
print(id(lst1))  # 139671899367680
# 扔到緩存池中，放在數(shù)組的尾部
del lst1

# 從緩存池中獲取，也會從數(shù)組的尾部開始拿
lst2 = [1, 2, 3]
print(id(lst2))  # 139671899367680

# 因此打印的地址是一樣的

L = None

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

del L