前言

在 Python 中處理大量字符串時，你可能會遇到意想不到的內(nèi)存占用問題。比如需要存儲一百萬個短字符串或數(shù)字，按每個字符串平均 10 字節(jié)、每個 64 位整數(shù) 8 個字節(jié)計(jì)算，理論上只需約 8 到 10MB 內(nèi)存，但實(shí)際用 Python 列表存儲時，內(nèi)存使用可能會到幾十MB。這背后的原因是什么？又該如何優(yōu)化？

1. 問題引入：列表存儲的內(nèi)存 “膨脹”

先看一段簡單的代碼，用普通列表存儲一百萬個短字符串、相同的短字符串、整數(shù)、相同的整數(shù)：

str_list = [f"item_{i}" for i in range(1000000)]
same_item_str_list = [f"item" for i in range(1000000)]
num_list = [i for i in range(1000000)]
same_item_num_list = [0 for i in range(1000000)]

直覺上，每個字符串 “item_xxx” 大約 8-10 字節(jié)，每個整數(shù) 8 個字節(jié)，一百萬條數(shù)據(jù)應(yīng)該在 8 到 10MB 左右。但實(shí)際內(nèi)存使用如何呢，我們用pympler來精確測量。

先安裝 pympler：

uv add pympler

修改代碼，增加測量內(nèi)存占用情況的打印：

from pympler import asizeof

str_list = [f"item_{i}" for i in range(1000000)]
same_item_str_list = [f"item" for i in range(1000000)]
num_list = [i for i in range(1000000)]
same_item_num_list = [0 for i in range(1000000)]

print(f"str_list列表內(nèi)存: {asizeof.asizeof(str_list) / 1024 / 1024:.2f} MB")
print(f"same_item_str_list列表內(nèi)存: {asizeof.asizeof(same_item_str_list) / 1024 / 1024:.2f} MB")
print(f"num_list列表內(nèi)存: {asizeof.asizeof(num_list) / 1024 / 1024:.2f} MB")
print(f"same_item_num_list列表內(nèi)存: {asizeof.asizeof(same_item_num_list) / 1024 / 1024:.2f} MB")

再次運(yùn)行，得到的內(nèi)存報(bào)告大致如下（具體數(shù)值因環(huán)境略有差異）：

str_list列表內(nèi)存: 61.46 MB
same_item_str_list列表內(nèi)存: 8.06 MB
num_list列表內(nèi)存: 38.57 MB
same_item_num_list列表內(nèi)存: 8.06 MB

可以看到，四個列表的內(nèi)存占用差異巨大：存儲不同字符串的str_list占用 61.46MB，存儲不同整數(shù)的num_list占用 38.57MB，而存儲相同字符串和相同數(shù)字的列表都只占用約 8MB 內(nèi)存。為什么同樣是存儲一百萬條數(shù)據(jù)，內(nèi)存占用會相差這么大呢？為什么和我們的根據(jù)理論猜測的占用大小不一樣呢？這需要先從數(shù)據(jù)的理論存儲與實(shí)際存儲差異說起。

2. 理論存儲與實(shí)際存儲的差異

我們常說 “每個 64 位整數(shù)占用 8 字節(jié)”“每個字符占用 1 字節(jié)”，這是硬件層面的理論存儲需求，但在 Python 中，由于對象模型的設(shè)計(jì)，實(shí)際存儲開銷會遠(yuǎn)高于理論值。

2.1 64位整數(shù)的存儲差異

• 理論值（8 字節(jié)）：指在硬件和底層編程語言（如 C 語言）中，存儲一個 64 位二進(jìn)制數(shù)字所需的最小空間，僅包含數(shù)值本身，沒有額外信息。
• Python 實(shí)際值（28 字節(jié)以上）：Python 中的整數(shù)是對象，其結(jié)構(gòu)PyIntObject（在 CPython 源碼中實(shí)際名為PyLongObject，整數(shù)對象統(tǒng)一使用長整型結(jié)構(gòu)）包含：
  • 引用計(jì)數(shù)（8 字節(jié)）：跟蹤對象被引用的次數(shù)，用于垃圾回收
  • 類型指針（8 字節(jié)）：標(biāo)識該對象是整數(shù)類型（指向PyLong_Type）
  • 長度字段（8 字節(jié)）：記錄整數(shù)占用的位數(shù)組長度（對于小整數(shù)固定為 1）
  • 數(shù)值數(shù)據(jù)（4 字節(jié)起）：存儲實(shí)際的整數(shù)數(shù)值（以位數(shù)組形式存儲，小整數(shù)至少占用 4 字節(jié)對齊空間）
    這些結(jié)構(gòu)字段總和為 8+8+8+4=28 字節(jié)，因此即使是最小的整數(shù)，在 Python 中也需要 28 字節(jié)內(nèi)存，是理論值的 3.5 倍。

2.2 短字符串的存儲差異

• 理論值（字符數(shù) ×1 字節(jié)）：在 ASCII 編碼中，每個字符占用 1 字節(jié)，一個 8 字符的字符串理論上只需 8 字節(jié)。
• Python 實(shí)際值（50 字節(jié)左右）：Python 的字符串對象PyUnicodeObject包含：
  • 引用計(jì)數(shù)（8 字節(jié)）和類型指針（8 字節(jié)）：基礎(chǔ)對象元數(shù)據(jù)
  • 字符串長度（8 字節(jié)）：記錄字符數(shù)量
  • 哈希值（8 字節(jié)）：用于快速比較和字典查找
  • 編碼標(biāo)志位（4 字節(jié)）：記錄字符串使用的編碼格式（如 ASCII、UTF-8 等）
  • 字符數(shù)據(jù)及內(nèi)存對齊（8 字符 ×1 字節(jié) + 4 字節(jié)對齊填充）：實(shí)際字符存儲需要按 8 字節(jié)對齊，8 個字符本需 8 字節(jié)，但為滿足內(nèi)存對齊要求會填充 4 字節(jié)
  • 額外內(nèi)存開銷：Python 內(nèi)存分配器會為小對象添加 4-8 字節(jié)的管理信息
    以 8 字符的 “item” 字符串為例，元數(shù)據(jù)（36 字節(jié)）+ 字符數(shù)據(jù)（8 字節(jié)）+ 對齊填充（4 字節(jié)）+ 分配器開銷（2 字節(jié)）≈50 字節(jié)，因此實(shí)際內(nèi)存是理論值的 6 倍多。
    這種理論與實(shí)際的差異，是導(dǎo)致列表內(nèi)存 “膨脹” 的基礎(chǔ)原因。當(dāng)存儲大量元素時，每個元素的額外開銷會累積成巨大的內(nèi)存差異。

3. 列表的內(nèi)存存儲本質(zhì)

了解了整數(shù)和字符串的理論存儲和實(shí)際存儲差異，我們就可以開始學(xué)習(xí)列表的內(nèi)存存儲了。Python 列表本質(zhì)上是指針數(shù)組，它存儲的不是元素本身，而是元素對象在內(nèi)存中的地址（指針）。在 64 位系統(tǒng)中，每個指針固定占用 8 字節(jié)，因此：

• 無論列表中的元素是什么類型，一個包含 100 萬個元素的列表，其指針數(shù)組本身的內(nèi)存固定為 8MB（1000000×8 字節(jié)）。
• 列表的總內(nèi)存 = 指針數(shù)組內(nèi)存 + 所有元素對象的內(nèi)存總和。
  這就解釋了為什么same_item_str_list和same_item_num_list的內(nèi)存都在 8MB 左右 —— 它們的指針數(shù)組占用 8MB，所有指針指向相同的內(nèi)存地址，因?yàn)樵貙ο笾挥幸粋€，所以元素對象的內(nèi)存幾乎可以忽略不計(jì)。而str_list和num_list內(nèi)存飆升的原因，正是元素對象的內(nèi)存開銷很大。

3.1 相同元素列表內(nèi)存少的核心原因：對象復(fù)用

當(dāng)列表中的元素完全相同時（如same_item_str_list全是 “item”，same_item_num_list全是 0），Python 會復(fù)用同一個對象，避免重復(fù)創(chuàng)建，從而大幅減少內(nèi)存開銷。

3.1.1 小整數(shù)的緩存復(fù)用機(jī)制

Python 對小整數(shù)（通常是 -5 到 256 之間） 采用預(yù)創(chuàng)建和緩存機(jī)制：這些整數(shù)在 Python 啟動時就被提前創(chuàng)建，并存入全局緩存池，后續(xù)使用時直接復(fù)用，不會重復(fù)分配內(nèi)存。

• 在same_item_num_list = [0 for i in range(1000000)]中，所有元素都是 0，而 0 屬于小整數(shù)，會被全局緩存復(fù)用。
• 整個列表中，所有指針都指向同一個 0 對象，因此元素對象的內(nèi)存只需存儲1 個 0 的內(nèi)存（約 28 字節(jié)）。
• 總內(nèi)存 = 指針數(shù)組（8MB）+1 個 0 對象內(nèi)存（可忽略）≈8MB（與實(shí)測的 8.06MB 一致）。
  這種機(jī)制極大提高了小整數(shù)的使用效率，尤其在循環(huán)計(jì)數(shù)、狀態(tài)標(biāo)記等場景中，避免了頻繁創(chuàng)建和銷毀整數(shù)對象的開銷。

3.1.2 字符串的駐留（Intern）機(jī)制

Python 會對短字符串、標(biāo)識符類字符串進(jìn)行 “駐留”（Intern）處理：相同的字符串會被存儲在全局字符串池中，后續(xù)使用時直接復(fù)用，不會重復(fù)創(chuàng)建新對象。

• 在same_item_str_list = [f"item" for i in range(1000000)]中，所有元素都是 “item”，這是一個短字符串且符合標(biāo)識符規(guī)則（字母組成），會被自動駐留。
• 整個列表中，所有指針都指向同一個 “item” 對象，元素對象的內(nèi)存只需存儲1 個 “item” 的內(nèi)存（約 50 字節(jié)）。
• 總內(nèi)存 = 指針數(shù)組（8MB）+1 個 “item” 對象內(nèi)存（可忽略）≈8MB（與實(shí)測的 8.06MB 一致）。
  字符串駐留機(jī)制主要用于優(yōu)化程序中頻繁出現(xiàn)的相同字符串，如變量名、關(guān)鍵字、常量字符串等，減少內(nèi)存浪費(fèi)和字符串比較的時間開銷。

3.2 不同元素列表內(nèi)存高的原因：對象重復(fù)創(chuàng)建

當(dāng)列表中的元素不同時（如str_list和num_list），每個元素都是獨(dú)立的新對象，需要為每個元素分配單獨(dú)的內(nèi)存，導(dǎo)致總內(nèi)存劇增。

3.2.1 不同整數(shù)的內(nèi)存開銷

num_list = [i for i in range(1000000)]中，元素是 0 到 999999：

• 其中 0 到 256 是小整數(shù)，會被緩存復(fù)用，但 257 到 999999 是大整數(shù)，每個大整數(shù)都是獨(dú)立的新對象。
• 每個 Python 整數(shù)對象（尤其是大整數(shù)）的內(nèi)存開銷約 28 字節(jié)（包含引用計(jì)數(shù)、類型指針等元數(shù)據(jù)）。
• 總內(nèi)存 = 指針數(shù)組（8MB）+ 約 999744 個大整數(shù)對象內(nèi)存（999744×28 字節(jié)≈27MB）≈35MB（與實(shí)測的 38.57MB 接近，差異來自小整數(shù)緩存和內(nèi)存對齊）。
  大整數(shù)沒有緩存機(jī)制，每個大整數(shù)都需要單獨(dú)分配內(nèi)存，這就是num_list內(nèi)存比相同元素?cái)?shù)字列表高的原因。

3.2.2 不同字符串的內(nèi)存開銷

str_list = [f"item_{i}" for i in range(1000000)]中，每個元素是不同的字符串（“item_0” 到 “item_999999”）：

• 這些字符串都是動態(tài)生成的不同內(nèi)容，不會被駐留復(fù)用，每個都是獨(dú)立的新字符串對象。
• 每個短字符串對象的內(nèi)存開銷約 50-60 字節(jié)（包含元數(shù)據(jù)和字符數(shù)據(jù)）。
• 總內(nèi)存 = 指針數(shù)組（8MB）+100 萬個獨(dú)立字符串對象內(nèi)存（1000000×50 字節(jié)≈48MB）≈56MB（與實(shí)測的 61.46MB 接近，差異來自字符串長度不同和元數(shù)據(jù)開銷）。
  動態(tài)生成的不同字符串無法被駐留機(jī)制復(fù)用，每個字符串都需要單獨(dú)存儲元數(shù)據(jù)和字符數(shù)據(jù)，導(dǎo)致內(nèi)存開銷遠(yuǎn)高于相同元素的字符串列表。

4. 內(nèi)存占用對比分析

5. 優(yōu)化建議：利用對象復(fù)用減少內(nèi)存開銷

了解了 Python 的對象復(fù)用機(jī)制后，我們可以采取以下策略優(yōu)化列表內(nèi)存占用：

1. 復(fù)用小整數(shù)和短字符串：在需要存儲大量重復(fù)元素的場景中，盡量使用小整數(shù)（-5 到 256）和可駐留的短字符串，避免動態(tài)生成不同的元素。
2. 使用數(shù)據(jù)結(jié)構(gòu)優(yōu)化重復(fù)元素存儲：對于包含大量重復(fù)元素的列表，可使用array模塊或 Pandas 的category類型，這些結(jié)構(gòu)會自動復(fù)用重復(fù)元素，減少內(nèi)存開銷。
3. 避免無意義的對象創(chuàng)建：在循環(huán)中避免重復(fù)創(chuàng)建相同的對象，例如將[f"abcdefghijklmnopqrstuvwxyz" for i in range(1000000)]改為item = "abcdefghijklmnopqrstuvwxyz"; [item for i in range(1000000)]，確保元素對象只創(chuàng)建一次。
4. 針對大整數(shù)和長字符串的優(yōu)化：對于大量大整數(shù)，可考慮使用 NumPy 數(shù)組存儲；對于大量字符串，可使用 Pandas 的StringDtype或category類型，利用其內(nèi)置的重復(fù)元素壓縮機(jī)制。

6. 總結(jié)

Python 列表的內(nèi)存占用差異主要來自元素對象的復(fù)用情況：相同元素的列表通過小整數(shù)緩存和字符串駐留機(jī)制復(fù)用對象，內(nèi)存開銷主要來自指針數(shù)組；而不同元素的列表需要為每個元素創(chuàng)建獨(dú)立對象，每個對象的元數(shù)據(jù)開銷累積導(dǎo)致內(nèi)存飆升。

在實(shí)際開發(fā)中，當(dāng)需要存儲大量數(shù)據(jù)時，應(yīng)充分利用 Python 的對象復(fù)用機(jī)制，選擇合適的數(shù)據(jù)結(jié)構(gòu)，避免無意義的對象重復(fù)創(chuàng)建。通過合理設(shè)計(jì)數(shù)據(jù)存儲方式，既能減少內(nèi)存占用，也能提高程序運(yùn)行效率。

最新評論