Python 記憶體分配時的小秘密

2021-10-01 22:53:34 字數 4223 閱讀 3119

python 中的sys模組極為基礎而重要,它主要提供了一些給直譯器使用(或由它維護)的變數,以及一些與直譯器強互動的函式。

這裡有個直觀的例子:

import sys

a = [1, 2]

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

# a、b 都只有兩個元素,所以直接占用的大小相等

sys.getsizeof(a) # 結果:80

sys.getsizeof(b) # 結果:80

上例說明了一件事:乙個靜態建立的列表,如果只包含兩個元素,那它自身占用的記憶體就是 80 位元組,不管其元素所指向的物件是什麼。

好了,擁有這把測量工具,我們就來**一下 python 的內建物件都藏了哪些小秘密吧。

對於我們熟知的一些空物件,例如空字串、空列表、空字典等等,不知道大家是否曾好奇過,是否曾思考過這些問題:空的物件是不是不占用記憶體呢?如果佔記憶體,那占用多少呢?為什麼是這樣分配的呢?

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

可見,雖然都是空物件,但是這些物件在記憶體分配上並不為「空」,而且分配得還挺大(記住這幾個數字哦,後面會考)。

排一下序:基礎數字《空元組 < 空字串 < 空列表 < 空集合 < 空字典。

這個小秘密該怎麼解釋呢?

因為這些空物件都是容器,我們可以抽象地理解:它們的一部分記憶體用於建立容器的骨架、記錄容器的資訊(如引用計數、使用量資訊等等)、還有一部分記憶體則是預分配的。

空物件並不為空,一部分原因是 python 直譯器為它們預分配了一些初始空間。在不超出初始記憶體的情況下,每次新增元素,就使用已有記憶體,因而避免了再去申請新的記憶體。

那麼,如果初始記憶體被分配完之後,新的記憶體是怎麼分配的呢?

import sys

letters = "abcdefghijklmnopqrstuvwxyz"

a = 

for i in letters:

print(f', sys.getsizeof(a) = ')

b = set()

for j in letters:

b.add(j)

print(f', sys.getsizeof(b) = ')

c = dict()

for k in letters:

c[k] = k

print(f', sys.getsizeof(c) = ')

分別給三類可變物件新增 26 個元素,看看結果如何:

由此能看出可變物件在擴充時的秘密:

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

那麼,靜態建立的物件是否也有這樣的分配機制呢?它跟動態擴容比,是否有所區別呢?

先看看集合與字典:

# 靜態建立物件

set_1 = 

set_2 = 

dict_1 = 

dict_2 = 

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 位元組,與這裡明顯矛盾。

所以,這個秘密昭然若揭:在元素個數相等時,靜態建立的列表所佔的記憶體有可能小於動態擴容時的記憶體!

也就是說,這兩種列表看似相同,實際卻不同!列表不等於列表!

前面提到了,擴充可變物件時,可能會申請新的記憶體。

那麼,如果反過來縮減可變物件,減掉一些元素後,新申請的記憶體是否會自動**掉呢?

import sys

a = [1, 2, 3, 4]

sys.getsizeof(a) # 初始值:96

sys.getsizeof(a) # 擴充後:128

a.pop()          # 縮減後:[1, 2, 3, 4]

sys.getsizeof(a) # 縮減後:128

如**所示,列表在一擴一縮後,雖然回到了原樣,但是所占用的記憶體空間可沒有自動釋放啊。其它的可變物件同理。

這就是 python 的小秘密了,「胖子無法減重原理」:瘦子變胖容易,縮減身型也容易,但是體重減不掉,哈哈~~~

使用 pop() 方法,只會縮減可變物件中的元素,但並不會釋放已申請的記憶體空間。

還有個 clear() 方法,它會清空可變物件的所有元素,讓我們試試看吧:

import sys

a = [1, 2, 3]

b = 

c = 

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 在分配記憶體時的幾個小秘密啦,看完之後,你是否覺得漲見識了呢?

對於那些沒有充分解釋的小秘密,今後我們再慢慢揭秘……

Python 記憶體分配時的小秘密

python 中的sys模組極為基礎而重要,它主要提供了一些給直譯器使用 或由它維護 的變數,以及一些與直譯器強互動的函式。它只計算直接占用的記憶體,而不計算物件內所引用物件的記憶體 這裡有個直觀的例子 import sys a 1,2 b a,a 即 1,2 1,2 sys.getsizeof a...

Python 記憶體分配時的小秘密

python 中的 sys 模組極為基礎而重要,它主要提供了一些給直譯器使用 或由它維護 的變數,以及一些與直譯器強互動的函式。該方法用於獲取乙個物件的位元組大小 bytes 它只計算直接占用的記憶體,而不計算物件內所引用物件的記憶體 這裡有個直觀的例子 import sys a 1,2 b a,a...

GRUB的小秘密

我看了一下grub的源 主要的竅門是這樣的 grub分兩個部分stage1,stage2 stage1.5 stage1就是512的引導區了,它載入放在檔案系統中的stage2。而stage2完成grub的其它的事情,命令列,配罝,從檔案系統中載入kernel。但是stage1只能有512個位元組的...