這篇文章主要給大家分享介紹了關於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 在分配內存時的幾個小祕密啦，看完之後，你是否覺得漲見識了呢？
你想明白了幾個呢，又產生了多少新的謎團呢？歡迎留言一起交流哦~
對於那些沒有充分解釋的小祕密，今後我們再慢慢揭祕……
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，謝謝大家對神馬文庫的支持。