python list存储对象_《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。
根據我們使用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對象將會被重新喚醒，重新分配元素列表所占的內存，重新擁抱新的元素列表。正如我，就喜歡紙片人，不停地換老婆，每當出現新的動漫，就會擁抱新的紙片人。
創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎總結
以上是生活随笔為你收集整理的python list存储对象_《python解释器源码剖析》第4章--python中的list对象的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 重复值处理 - 清洗 DataFrame
- 下一篇： 用python生成云词汇_用python