4.0 序

python中的list對象，底層對應(yīng)的則是PyListObject。如果你熟悉C++，那么會很容易和C++中的list聯(lián)系起來。但實(shí)際上，這個C++中的list大相徑庭，反而和STL中的vector比較類似

4.1 PyListObject對象

我們知道python里面的list對象是支持對元素進(jìn)行增刪改查等操作的，list對象里面存儲的，底層無一例外都是PyObject * 指針。所以實(shí)際上我們可以這樣看待python底層的PyListObject：vector。

根據(jù)我們使用python的list的經(jīng)驗，我們可以得出以下兩個結(jié)論。

每個PyListObject維護(hù)的元素個數(shù)可以不一樣：所以這是一個變長對象

可以對PyListObject維護(hù)的元素進(jìn)行添加、刪除等操作，所以這是一個可變對象

我們來看一下，PyListObject對象的定義。

typedef struct {

//不用解釋，PyObject加上一個ob_size

PyObject_VAR_HEAD

/* ob_item就對應(yīng)list對象存儲的元素，ob_item[0]就是list[0]

但是我們發(fā)現(xiàn)這是一個二級指針，至于這里的二級指針是如何和

python中l(wèi)ist掛上鉤的，我們后面會詳細(xì)介紹

*/

PyObject **ob_item;

/*

這個allocated是什么呢?其實(shí)我在最開始的那一章介紹python源碼的時候就已經(jīng)解釋過了。

這里再來說一遍，我們知道PyObject_VAR_HEAD里面有一個ob_size，這是表示變長對象里面

已經(jīng)存儲了多少個元素了。而這個allocated，則表示最大能存儲多少個元素，因為這是一個

變長對象，因此就意味著可以隨時對其進(jìn)行刪除、增加等操作，如果每次添加都要malloc，那么

效率會非常低下，因此python會事先申請一大份內(nèi)存，而allocated正是記錄了這個一大份內(nèi)存

的容量是多少。而ob_size則是目前已經(jīng)存了多少個，如果你學(xué)過golang，你會發(fā)現(xiàn)ob_size對應(yīng)

golang里面切片的len，而allocated則對應(yīng)cap。假設(shè)一個能容納10個元素的PyListObject對象

已經(jīng)存了5個元素，那么ob_size就是5，allocated就是10。

從這里我們已經(jīng)能夠看出：

0 <= ob_size <= allocated

len(list) == ob_size 注意這里的list指的都是list的實(shí)例對象，而不是list這個類本身

ob_item == NULL 意味著 ob_size == allocated == 0

*/

Py_ssize_t allocated;

} PyListObject;

剛才說了，python事先會申請一大份內(nèi)存，這個并不是指在創(chuàng)建的時候申請一大份內(nèi)存，而是在擴(kuò)容的時候，會申請更多的內(nèi)存。

PyListObject有一個resize操作，不用想，這個肯定是修改列表容量的。因為allocated一開始是固定的，但是隨著ob_size越來越大，肯定要申請更多的內(nèi)存，即增大allocated

static int

list_resize(PyListObject *self, Py_ssize_t newsize)

{

//參數(shù)self就是PyListObject *對象本身

//參數(shù)newsize就是當(dāng)前的ob_size

PyObject **items;

//既然resize，所以new_allocated就是新的最大容量

size_t new_allocated, num_allocated_bytes;

//這里的獲取當(dāng)前PyListObject的allocated

Py_ssize_t allocated = self->allocated;

//如果當(dāng)前的容量大于newsize(ob_size)，并且newsize >= 容量除以2

//基本上啥也沒干直接返回，這一步不需要關(guān)心。

//因為執(zhí)行這一步表示內(nèi)存不需要重新分配

if (allocated >= newsize && newsize >= (allocated >> 1)) {

assert(self->ob_item != NULL || newsize == 0);

Py_SIZE(self) = newsize;

return 0;

}

/*

計算重新分配的內(nèi)存的大小

這一步很重要，新分配的容量就等于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;

//所占的字節(jié)，就是new_allocated * sizeof(PyObject *)

//但是我們發(fā)現(xiàn)這里乘上的是一個指針的大小，這是一個很關(guān)鍵的問題，我們后面會詳談

num_allocated_bytes = new_allocated * sizeof(PyObject *);

//為ob_item申請內(nèi)存

items = (PyObject **)PyMem_Realloc(self->ob_item, num_allocated_bytes);

if (items == NULL) {

PyErr_NoMemory();

return -1;

}

//指向新的內(nèi)存塊，擴(kuò)展列表。

self->ob_item = items;

//將ob_size變?yōu)閚ewsize

Py_SIZE(self) = newsize;

//將allocated變?yōu)樾碌膎ew_allocated

self->allocated = new_allocated;

return 0;

}

我們來剛才說，python中的list申請容量是按照new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6)這樣的規(guī)則來的，我們來看看。

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個字節(jié)啊，咦，那列表里面存"xx" * 1000，這也占8個字節(jié)？

# 沒錯，是的，關(guān)于為什么我們會后面說。

# 同時這也引出了一個問題：為什么python中l(wèi)ist對象在支持存儲不同類型數(shù)據(jù)的前提下，還能保證查詢的時間復(fù)雜度是O(1)呢？

# 先保留這些疑問，后面會解答

allocated = (l.__sizeof__() - [].__sizeof__()) // 8

print(allocated, end=" ") # 0 4 8 16 25 35 46 58 72 88 106

可以看到我們計算的結(jié)果和官方源碼給的是一樣的，其實(shí)這是廢話，python解釋器就是按照官方源碼寫的。但還有一個特殊情況：

l = [1, 2, 3, 4, 5]

print((l.__sizeof__() - [].__sizeof__()) // 8) # 5

"""

結(jié)果是5，我們在之前的結(jié)果并沒有看見5啊。這是因為對于初始化一個列表時，有多少元素，容量就是多少，此時allocated和ob_size是相等的

"""

l.append(6)

"""

什么時候會擴(kuò)容呢？是當(dāng)我們往列表進(jìn)行append的時候，解釋器發(fā)現(xiàn)容量不夠。

比如此時上面的ob_size和allocated都是5，但是當(dāng)append一個6的時候，解釋器發(fā)現(xiàn)容量不夠了

ob_size已經(jīng)超過allocated了，于是才會擴(kuò)容。按照 newsize + (newsize >> 3) + (if newsize < 9 ? 3 : 6)

"""

# 此時擴(kuò)容的結(jié)果就是9，盡管里面只存儲的了6個元素，但是人家內(nèi)存已經(jīng)分配了

# 所以計算的就是9個元素的內(nèi)存，那么除以8，得到的就是9，即分配的內(nèi)存能夠容納9個元素

print((l.__sizeof__() - [].__sizeof__()) // 8) # 9

在這里還想問一句，對于初始化一個列表，你認(rèn)為l =?[]和l?= list()哪個速度更快呢？首先這兩者你print之后得到的都是一個[]

答案是l?= []更快，因為python中的list在C語言的層面可以看做是allocated-array：過分配數(shù)組，直接使用的是底層C語言的數(shù)據(jù)結(jié)構(gòu)。而l?= list()相當(dāng)于是python層面上的一個函數(shù)調(diào)用，既然調(diào)用肯定要創(chuàng)建棧幀、記錄函數(shù)參數(shù)等等，會進(jìn)行額外的資源消耗。

為什么list通過索引查找元素的時間復(fù)雜度是O(1)

我們之前說了，其實(shí)不說大家也知道，python里面列表通過索引定位元素的時間復(fù)雜度是O(1)，可是列表里面存放的元素大小不一，是怎么做到的呢？還記的我們之前說，列表里面存儲的元素都占8個字節(jié)嗎？我們再來驗證一下。

import sys

l = ["a" * 1000, "b" * 1000]

print(sys.getsizeof(l) - sys.getsizeof([])) # 16

print(sys.getsizeof(l[0]) - sys.getsizeof("")) # 1000

"""

由于python中的對象除了值本身，還有其他的信息

比如引用計數(shù)、ob_size等等，這些都是要占內(nèi)存的。

我們把這些值減掉，比如列表的話減去一個[]，字符串減去一個""，

把共同具有的那些特征那么所占的內(nèi)存去掉，那么剩下來的就是值本身占的內(nèi)存

"""

可以看到，加上本身的信息，l[0]占了不止1000個字節(jié)，同理l[1]也是，但是我們計算列表的時候，發(fā)現(xiàn)里面的值只占了16個字節(jié)，說明每一個值占了8個字節(jié)。其實(shí)任何一個對象存在列表里面都是8個字節(jié)，而我們看PyListObject的定義，里面有一個PyObject?**ob_item，因此很容易猜到，python的list里面存儲的實(shí)際上是指針。其實(shí)這個ob_item是一個指向指針數(shù)組的指針，這個指針指向了指針數(shù)組的首地址。因此我們可以看到，python的list、tuple，實(shí)際是哪個都是采用了元素外置的方法，元素的實(shí)際的值都存儲在堆上，至于列表本身，存儲的不過是這些元素的內(nèi)存指針。不管你值本身占的內(nèi)存有多大，但是內(nèi)存地址是固定的，在64位機(jī)器上是8個字節(jié)。通過索引可以瞬間計算出指針的偏移量，從而找到對應(yīng)元素的指針，打印的時候會自動打印指針?biāo)赶虻膬?nèi)存。索引我們使用id(l[0])查看第一個元素的內(nèi)存地址時，會打印一串?dāng)?shù)字，也就是內(nèi)存地址，但是實(shí)際上l[0]在python的底層中，存儲的就是地址。我們打印的時候，打印的也是指針，只不過我們沒有權(quán)限操作指針，能有權(quán)限操作指針的只有解釋器，因此當(dāng)我們打印會自動打印指針的指向內(nèi)存，我們可以認(rèn)為盡管存儲的是指針，但是最終操作的都是指針指向的內(nèi)存。

4.2 PyListObject對象的創(chuàng)建與維護(hù)

4.2.1 創(chuàng)建對象

為了創(chuàng)建一個列表，python底層只提供了唯一的一條途徑--PyList_New。這個函數(shù)接收一個size參數(shù)，從而允許我們在創(chuàng)建一個PyListObject對象時指定元素個數(shù)。這里僅僅是指定了元素個數(shù)，卻沒有指定元素是什么，我們來看看創(chuàng)建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 {

//不可用的時候，申請內(nèi)存

op = PyObject_GC_New(PyListObject, &PyList_Type);

if (op == NULL)

return NULL;

#ifdef SHOW_ALLOC_COUNT

count_alloc++;

#endif

}

//如果size小于0，ob_item設(shè)置為NULL

if (size <= 0)

op->ob_item = NULL;

else {

//否則的話，為維護(hù)的列表申請空間

op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));

if (op->ob_item == NULL) {

Py_DECREF(op);

return PyErr_NoMemory();

}

}

//設(shè)置ob_size和allocated，然后返回op

Py_SIZE(op) = size;

op->allocated = size;

_PyObject_GC_TRACK(op);

return (PyObject *) op;

}

通過源碼我們可以看到，python在創(chuàng)建列表的時候，底層實(shí)際上是分為兩部分的，一部分是創(chuàng)建PyListObject對象，另一部分是PyListObject對象所維護(hù)的列表，這是兩塊分離的內(nèi)存，它們通過ob_item建立了聯(lián)系。咦，有人會問，維護(hù)的列表不是PyListObject結(jié)構(gòu)體的一個屬性嗎？是的，在這里PyListObject指的是不包含其維護(hù)列表的PyListObject，當(dāng)然有時我們也用PyListObject專門只指其維護(hù)的列表、或者我們有時也說PyListObject所維護(hù)的列表等等，這些說法不用刻意區(qū)分，通過上下文是可以理解的。

我們注意到源碼里面有一個緩沖池，是的，創(chuàng)建PyListObject對象時，會先檢測緩沖池free_lists里面是否有可用的對象，有的話直接拿來用，否則通過malloc在系統(tǒng)堆上申請。緩沖池中最多維護(hù)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對象的個數(shù)，如果沒滿，就添加到緩沖池，

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創(chuàng)建時，顯然numfree是0，不會走緩沖池，而是直接在堆上申請，假設(shè)我們申請創(chuàng)建有6個元素的PyListObject對象，那么會調(diào)用PyList_New(6)來創(chuàng)建PyListObject對象，在對象完成之后，第一個PyListObject對象就完成了。

通過上圖，我們可以拋出一個問題。

import pandas as pd

# 具有6個元素的列表

l = [1, "xx", int, {}, pd, ()]

print(l.__sizeof__()) # 88

print([].__sizeof__()) # 40

"""

兩者相減得到48,6個元素，每個指針正好8字節(jié)。

"""

我們看到元素外置、存儲指針，6個元素總共用了48個字節(jié)，但是剩下的40個字節(jié)是哪來的。還記得嗎？python中的對象在底層都是一個結(jié)構(gòu)體實(shí)例，我們計算的可以不僅僅是維護(hù)的值，還有其他的信息啊。首先從圖中可以看出，ob_refcnt:引用計數(shù)，占八個字節(jié)、ob_type：PyTypeObject對象的一個指針，八個字節(jié)、ob_size：容納元素的個數(shù)，八個字節(jié)、ob_item：這是一個二級指針，指向了指針數(shù)組的指針，八個字節(jié)、allocated：容量，八個字節(jié)，正好40個字節(jié)，再加上ob_item指向的指針數(shù)組里面有6和元素，再加上6*8=48，正好88個字節(jié)。

然后我們看看PyListObject對象是如何設(shè)置元素的。

int

PyList_SetItem(PyObject *op, Py_ssize_t i,

PyObject *newitem)

{//參數(shù)為：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表示數(shù)組的首地址

//ob_item + i直接獲取數(shù)組中索引為i的元素的指針

//當(dāng)然數(shù)組里面存儲的本身也是一個指針，所以這里的p是一個二級指針

p = ((PyListObject *)op) -> ob_item + i;

//直接將*p，也就是數(shù)組中索引為i的指針(一級)指向的元素設(shè)置為newitem

Py_XSETREF(*p, newitem);

return 0;

}

假設(shè)我們設(shè)置l[2]=100的話，那么

4.2.3 插入元素

設(shè)置元素和和插入元素是不同的，設(shè)置元素不會導(dǎo)致ob_item指向的內(nèi)存發(fā)生改變，而插入元素可能會導(dǎo)致ob_item指向的內(nèi)存發(fā)生變化

int

PyList_Insert(PyObject *op, Py_ssize_t where, PyObject *newitem)

{

//類型檢查

if (!PyList_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

//底層又調(diào)用ins1

return ins1((PyListObject *)op, where, newitem);

}

static int

ins1(PyListObject *self, Py_ssize_t where, PyObject *v)

{

/*參數(shù)self：PyListObject *

參數(shù)where：索引

參數(shù)v：插入的值，這是一個PyObject *指針，因為list里面存的都是指針

*/

//i:后面for循環(huán)遍歷用的，n則是當(dāng)前列表的元素個數(shù)

Py_ssize_t i, n = Py_SIZE(self);

//指向指針數(shù)組的二級指針

PyObject **items;

//如果v是NULL，錯誤的內(nèi)部調(diào)用

if (v == NULL) {

PyErr_BadInternalCall();

return -1;

}

//列表的元素個數(shù)不可能無限增大，一般當(dāng)你還沒創(chuàng)建到PY_SSIZE_T_MAX個對象時

//你內(nèi)存就已經(jīng)玩完了，但是python仍然做了檢測當(dāng)達(dá)到這個PY_SSIZE_T_MAX時，會報出內(nèi)存溢出錯誤

if (n == PY_SSIZE_T_MAX) {

PyErr_SetString(PyExc_OverflowError,

"cannot add more objects to list");

return -1;

}

//調(diào)整列表容量，既然要inert，那么就勢必要多出一個元素

//這個元素還沒有設(shè)置進(jìn)去，但是先把這個坑給留出來

//當(dāng)然如果容量夠的話，是不會擴(kuò)容的，只有當(dāng)容量不夠的時候才會擴(kuò)容

if (list_resize(self, n+1) < 0)

return -1;

//確定插入點(diǎn)

//這里可以看到如果where小于0，那么我們就加上n，也就是當(dāng)前列表的元素個數(shù)

//比如有6個元素，那么我們where=-1，加上6，就是5，顯然就是insert在最后一個索引的位置上

if (where < 0) {

where += n;

//如果吃撐了，寫個-100，加上元素的個數(shù)還是小于0

if (where < 0)

//那么where=0，就在開頭插入

where = 0;

}

//如果where > n，那么就索引為n的位置插入，

//可元素個數(shù)為n，最大索引是n-1啊，對，所以此時就相當(dāng)于append

if (where > n)

where = n;

//拿到原來的二級指針，指向一個指針數(shù)組

items = self->ob_item;

//然后讓不斷遍歷，把索引為i的值賦值給索引為i+1，既然是在where處插入

//那么where之前的就不需要動了，到where處就停止了

for (i = n; --i >= where; )

items[i+1] = items[i];

//增加引用計數(shù)，因為它作為列表的一個元素了

Py_INCREF(v);

//將where處的值設(shè)置成v，還記得這個v嗎？對，沒錯，這是一個PyObject *指針

//打印的話，會打印*v

items[where] = v;

return 0;

}

所以可以看到，python插入數(shù)據(jù)是非常靈活的。不管你在什么位置插入，都是合法的。因為它會自己調(diào)整位置，在確定位置之后，會將當(dāng)前位置以及之后的所有元素向后挪動一個位置，空出來的地方設(shè)置為插入的值。因此熟悉C++的話，會發(fā)現(xiàn)這和vector是非常類似的，但是和C++中的list確實(shí)大相徑庭的，盡管名字一樣。

既然插入元素，那么自然少不了append直接往尾部追加元素了。這個就比較簡單了，就相當(dāng)于insert的where>n，直接將索引為n的地方設(shè)置為append的值即可。這里就不看源碼了，比較簡單。只是如果容量夠的話，是不需要重新分配空間的。

4.2.4 刪除元素

刪除元素，對于python的列表來說，直接調(diào)用l.remove即可

l = [1, 1, 2, 3]

l.remove(1)

print(l) # [1, 2, 3]

# 會自動刪除第一個出現(xiàn)的元素

那么底層是如何實(shí)現(xiàn)的呢？

static PyObject *

list_remove(PyListObject *self, PyObject *value)

{

//刪除值，對于底層來說，就是刪除數(shù)組中值對應(yīng)的指針。

//所以value仍然是PyObject *類型

//i，for循環(huán)遍歷用的

Py_ssize_t i;

//從0開始，直到不小于ob_size

for (i = 0; i < Py_SIZE(self); i++) {

//將指針數(shù)組里面的每一個元素和value進(jìn)行比較

int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);

//如果cmp大于0，表示元素和value匹配

if (cmp > 0) {

//調(diào)用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其實(shí)起到的是替換的作用，只不過也可以充當(dāng)刪除

//從源碼中可以看出把i: i+1部分的元素給刪了

/*

l = [1, 2, 3, 4]

l[0: 1] = []

print(l) # [2, 3, 4]

*/

既然是刪除，那么和insert一樣。全局都會進(jìn)行移動，比如我把第一個元素刪了，那么第二個元素要頂在第一個元素的位置，第n個元素要頂在第n-1個元素的位置上。

4.3 PyListObject對象緩沖池

還記的我們之前說的緩沖池free_lists嗎？是用來緩沖PyListObject對象的，但是現(xiàn)在問題來了，這些緩沖的PyListObject對象從哪里獲取的呢？或者說是何時創(chuàng)建的呢？答案其實(shí)一開始就說了，是在一個PyListObject對象銷毀的時候創(chuàng)建的。

static void

list_dealloc(PyListObject *op)

{

//遍歷用的

Py_ssize_t i;

PyObject_GC_UnTrack(op);

Py_TRASHCAN_SAFE_BEGIN(op)

//改變每一個元素的引用計數(shù)

//銷毀PyListObject對象維護(hù)的元素列表

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);

}

//如果緩沖池未滿，那么放回到緩沖池當(dāng)中

if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))

free_list[numfree++] = op;

else

Py_TYPE(op)->tp_free((PyObject *)op);

Py_TRASHCAN_SAFE_END(op)

}

我們知道在創(chuàng)建一個新的PyListObject對象時，實(shí)際上是分為兩步的，先創(chuàng)建PyListObject，然后創(chuàng)建其維護(hù)的元素列表。同理，在銷毀一個PyListObject對象時，先銷毀銷毀維護(hù)的元素列表，然后再釋放PyListObject對象自身

現(xiàn)在可以很清晰地明白了，原本空蕩蕩的緩沖池其實(shí)是被已經(jīng)死去的PyListObject對象填充了，在以后創(chuàng)建新的PyListObject對象時，python會首先喚醒這些死去的PyListObject對象，給它們一個洗心革面、重新做人的機(jī)會。但注意的是，這里的緩沖僅僅是PyListObject對象，對于其維護(hù)的列表，已經(jīng)不再指向了，引用減少，那么這些元素就大難臨頭各自飛了，或生存、或毀滅，不再被對應(yīng)的PyListObject的那個指針?biāo)`。但是為什么要這么做呢？可以想一下，如果繼續(xù)維護(hù)的，那么很可能會產(chǎn)生懸空指針的問題，因此這些元素所占的空間必須交還給系統(tǒng)(前提是沒有指針指向了)

但是實(shí)際上，是可以將PyListObject對象維護(hù)的元素列表保留的，即只調(diào)整引用計數(shù)，并將元素都設(shè)置為NULL，但是并不釋放內(nèi)存空間。因此這樣一來，釋放的內(nèi)存不會交給系統(tǒng)堆，那么再次分配的時候，速度會快很多。但是這樣帶一個問題就是，這些內(nèi)存沒人用也會一直占著，并且只能供PyListObject對象使用，因此python還是為避免消耗過多內(nèi)存，采取將元素列表的內(nèi)存交換給了系統(tǒng)堆這樣的做法，在時間和空間上選擇了空間。

我們之前的PyListObject對象的示意圖，如果在緩沖池當(dāng)中應(yīng)該變成什么樣子呢？

在下一次創(chuàng)建新的list對象時，這個PyListObject對象將會被重新喚醒，重新分配元素列表所占的內(nèi)存，重新?lián)肀碌脑亓斜?。正如?#xff0c;就喜歡紙片人，不停地?fù)Q老婆，每當(dāng)出現(xiàn)新的動漫，就會擁抱新的紙片人。

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結(jié)

以上是生活随笔為你收集整理的python list存储对象_《python解释器源码剖析》第4章--python中的list对象的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。