(給Python開發者加星標，提升Python技能)

作者：豌豆花下貓 (本文來自作者投稿)

Python 中的sys模塊極為基礎而重要，它主要提供了一些給解釋器使用(或由它維護)的變量，以及一些與解釋器強交互的函數。

本文將會頻繁地使用該模塊的getsizeof()方法，因此，我先簡要介紹一下：

• 該方法用于獲取一個對象的字節大小(bytes)

• 它只計算直接占用的內存，而不計算對象內所引用對象的內存

這里有個直觀的例子：

import?sys

a?=?[1,?2]
b?=?[a,?a]??#?即?[[1,?2],?[1,?2]]

#?a、b?都只有兩個元素，所以直接占用的大小相等
sys.getsizeof(a)?#?結果：80
sys.getsizeof(b)?#?結果：80

上例說明了一件事：一個靜態創建的列表，如果只包含兩個元素，那它自身占用的內存就是 80 字節，不管其元素所指向的對象是什么。

好了，擁有這把測量工具，我們就來探究一下 Python 的內置對象都藏了哪些小秘密吧。

1、空對象不是“空”的！

對于我們熟知的一些空對象，例如空字符串、空列表、空字典等等，不知道大家是否曾好奇過，是否曾思考過這些問題：

空的對象是不是不占用內存呢？如果占內存，那占用多少呢？為什么是這樣分配的呢？

直接上代碼吧，一起來看看幾類基本數據結構的空對象的大小：

import?sys
sys.getsizeof("")??????#?49
sys.getsizeof([])??????#?64
sys.getsizeof(())??????#?48
sys.getsizeof(set())???#?224
sys.getsizeof(dict())??#?240

#?作為參照：
sys.getsizeof(1)???????#?28
sys.getsizeof(True)????#?28

可見，雖然都是空對象，但是這些對象在內存分配上并不為“空”，而且分配得還挺大(記住這幾個數字哦，后面會考)。

排一下序：基礎數字

這個小秘密該怎么解釋呢？

因為這些空對象都是容器，我們可以抽象地理解：它們的一部分內存用于創建容器的骨架、記錄容器的信息(如引用計數、使用量信息等等)、還有一部分內存則是預分配的。

2、內存擴充不是均勻的！

空對象并不為空，一部分原因是 Python 解釋器為它們預分配了一些初始空間。在不超出初始內存的情況下，每次新增元素，就使用已有內存，因而避免了再去申請新的內存。

那么，如果初始內存被分配完之后，新的內存是怎么分配的呢？

import?sys
letters?=?"abcdefghijklmnopqrstuvwxyz"

a?=?[]
for?i?in?letters:
????a.append(i)
????print(f'{len(a)},?sys.getsizeof(a)?=?{sys.getsizeof(a)}')

b?=?set()
for?j?in?letters:
????b.add(j)
????print(f'{len(b)},?sys.getsizeof(b)?=?{sys.getsizeof(b)}')

c?=?dict()
for?k?in?letters:
????c[k]?=?k
????print(f'{len(c)},?sys.getsizeof(c)?=?{sys.getsizeof(c)}')

分別給三類可變對象添加 26 個元素，看看結果如何：

由此能看出可變對象在擴充時的秘密：

• 超額分配機制：申請新內存時并不是按需分配的，而是多分配一些，因此當再添加少量元素時，不需要馬上去申請新內存

• 非均勻分配機制：三類對象申請新內存的頻率是不同的，而同一類對象每次超額分配的內存并不是均勻的，而是逐漸擴大的

3、列表不等于列表！

以上的可變對象在擴充時，有相似的分配機制，在動態擴容時可明顯看出效果。

那么，靜態創建的對象是否也有這樣的分配機制呢？它跟動態擴容比，是否有所區別呢？

先看看集合與字典：

#?靜態創建對象
set_1?=?{1,?2,?3,?4}
set_2?=?{1,?2,?3,?4,?5}
dict_1?=?{'a':1,?'b':2,?'c':3,?'d':4,?'e':5}
dict_2?=?{'a':1,?'b':2,?'c':3,?'d':4,?'e':5,?'f':6}

sys.getsizeof(set_1)??#?224
sys.getsizeof(set_2)??#?736
sys.getsizeof(dict_1)?#?240
sys.getsizeof(dict_2)?#?368

看到這個結果，再對比上一節的截圖，可以看出：在元素個數相等時，靜態創建的集合/字典所占的內存跟動態擴容時完全一樣。

這個結論是否適用于列表對象呢？一起看看：

list_1?=?['a',?'b']
list_2?=?['a',?'b',?'c']
list_3?=?['a',?'b',?'c',?'d']
list_4?=?['a',?'b',?'c',?'d',?'e']

sys.getsizeof(list_1)??#?80
sys.getsizeof(list_2)??#?88
sys.getsizeof(list_3)??#?96
sys.getsizeof(list_4)??#?104

上一節的截圖顯示，列表在前 4 個元素時都占 96 字節，在 5 個元素時占 128 字節，與這里明顯矛盾。

所以，這個秘密昭然若揭：在元素個數相等時，靜態創建的列表所占的內存有可能小于動態擴容時的內存！

也就是說，這兩種列表看似相同，實際卻不同！列表不等于列表！

4、消減元素并不會釋放內存！

前面提到了，擴充可變對象時，可能會申請新的內存。

那么，如果反過來縮減可變對象，減掉一些元素后，新申請的內存是否會自動回收掉呢？

import?sys
a?=?[1,?2,?3,?4]
sys.getsizeof(a)?#?初始值：96
a.append(5)??????#?擴充后：[1, 2, 3, 4, 5]
sys.getsizeof(a)?#?擴充后：128
a.pop()??????????#?縮減后：[1, 2, 3, 4]
sys.getsizeof(a)?#?縮減后：128

如代碼所示，列表在一擴一縮后，雖然回到了原樣，但是所占用的內存空間可沒有自動釋放啊。其它的可變對象同理。

這就是 Python 的小秘密了，“胖子無法減重原理”：瘦子變胖容易，縮減身型也容易，但是體重減不掉，哈哈~~~

5、空字典不等于空字典！

使用 pop() 方法，只會縮減可變對象中的元素，但并不會釋放已申請的內存空間。

還有個 clear() 方法，它會清空可變對象的所有元素，讓我們試試看吧：

import?sys
a?=?[1,?2,?3]
b?=?{1,?2,?3}
c?=?{'a':1,?'b':2,?'c':3}

sys.getsizeof(a)?#?88
sys.getsizeof(b)?#?224
sys.getsizeof(c)?#?240

a.clear()????????#?清空后：[]
b.clear()????????#?清空后：set()
c.clear()????????#?清空后：{}，也即 dict()

調用 clear() 方法，我們就獲得了幾個空對象。

在第一小節里，它們的內存大小已經被查驗過了。(前面說過會考的，請默寫回看下)

但是，如果這時再查驗的話，你會驚訝地發現，這些空對象的大小跟前面查的并不完全一樣！

#?承接前面的清空操作：
sys.getsizeof(a)?#?64
sys.getsizeof(b)?#?224
sys.getsizeof(c)?#?72

空列表與空元組的大小不變，然而空字典(72)竟然比前面的空字典(240)要小很多！

也就是說，列表與元組在清空元素后，回到起點不變初心，然而，字典這家伙卻是“賠了夫人又折兵”，不僅把“吃”進去的全吐出來了，還把自己的老本給虧掉了！

字典的這個秘密藏得挺深的，說實話我也是剛剛獲知，百思不得其解……

以上就是 Python 在分配內存時的幾個小秘密啦，看完之后，你是否覺得漲見識了呢？

你想明白了幾個呢，又產生了多少新的謎團呢？歡迎留言一起交流哦~

對于那些沒有充分解釋的小秘密，今后我們再慢慢揭秘……

【本文作者】

豌豆花下貓：某985高校畢業生， 兼具極客思維與人文情懷 。個人公眾號Python貓， 專注python技術、數據科學和深度學習。

推薦閱讀

(點擊標題可跳轉閱讀)

為什么 Python 3 把 print 改為函數？

在 Win 上做 Python 開發？當然是用官方的 MS Terminal 和 VS Code 了

覺得本文對你有幫助？請分享給更多人

關注「Python開發者」加星標，提升Python技能

好文章，我在看??

總結

以上是生活随笔為你收集整理的python 去空_Python 内存分配时的小秘密的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。