寫 Python 時總覺得“不用手動釋放內存真方便”，但接手一個跑了幾天就內存爆炸的腳本後，我才意識到：自動回收不代表不用關心內存。Python 的垃圾回收機制確實能幫我們處理大部分內存管理工作，但瞭解它的原理，才能避免內存泄漏，讓程序更高效。

一、垃圾回收的核心原理

Python 主要通過三種機制回收內存：

1. 引用計數：最基礎的回收方式

每個對象都有一個“引用計數器”，當引用次數變為 0 時，對象會被立即回收。

a = [1, 2, 3]  # 列表對象引用計數為 1
b = a           # 引用計數變為 2
b = None        # 引用計數減為 1
a = None        # 引用計數變為 0，對象被回收

這種方式簡單高效，但解決不了“循環引用”的問題：

# 循環引用示例
class Node:
    def __init__(self):
        self.next = None

n1 = Node()
n2 = Node()
n1.next = n2    # n1 引用 n2
n2.next = n1    # n2 引用 n1，形成循環

n1 = None       # n1 引用計數變為 0，但 n2 還被 n1.next 引用
n2 = None       # n2 引用計數變為 0，但 n1 還被 n2.next 引用
# 此時兩個對象引用計數都是 1，卻無法訪問，造成內存泄漏

2. 標記-清除：解決循環引用

為了處理循環引用，Python 定期執行“標記-清除”：

  1. 從根對象（如全局變量、棧幀中的變量）出發，標記所有可達對象
  2. 清除所有未被標記的對象（包括循環引用的孤立對象）

這個過程會暫停程序執行（稱為“stop the world”），但 Python 會根據內存分配情況動態調整執行頻率，減少對性能的影響。

3. 分代回收：優化回收效率

Python 把對象按存活時間分為 3 代（0 代、1 代、2 代）：

  • 新創建的對象屬於 0 代
  • 經過一次回收存活下來的對象升入下一代
  • 年代越高，回收頻率越低

這樣能減少對長期存活對象的檢查，提高效率。

二、常見內存問題與解決方案

1. 循環引用導致內存泄漏

前面的 Node 例子就是典型情況，解決辦法有兩種：

方法一：使用弱引用（weakref） 弱引用不會增加對象的引用計數，適合處理循環引用：

import weakref

class Node:
    def __init__(self):
        self.next = None

n1 = Node()
n2 = Node()
n1.next = weakref.ref(n2)  # 弱引用 n2
n2.next = weakref.ref(n1)  # 弱引用 n1

n1 = None
n2 = None  # 此時兩個對象引用計數都為 0，會被正常回收

方法二：手動打破循環 在對象生命週期結束時，顯式斷開循環引用：

def cleanup(node):
    if node.next:
        node.next.next = None  # 斷開循環
        node.next = None

# 使用完節點後調用
cleanup(n1)
n1 = None
n2 = None

2. 大對象佔用內存過多

處理大量數據時（如讀取大文件、創建百萬級列表），容易佔用過多內存。

優化方案：使用生成器代替列表 生成器按需產生數據，不會一次性佔用大量內存：

# 不好的寫法：創建包含1000萬個數的列表，佔用大量內存
big_list = [i * 2 for i in range(10_000_000)]

# 好的寫法：生成器表達式，內存佔用極低
big_generator = (i * 2 for i in range(10_000_000))

# 遍歷處理
for num in big_generator:
    process(num)  # 每次只加載一個元素到內存

3. 全局變量未及時清理

全局變量的生命週期與程序一致，長期持有大對象會導致內存一直被佔用：

# 不好的寫法：全局變量持有大列表
global_data = []

def load_data():
    global global_data
    global_data = [i for i in range(10_000_000)]  # 加載大量數據

def process_data():
    # 使用 global_data 處理數據
    ...

load_data()
process_data()
# 即使處理完，global_data 依然佔用內存

# 優化：處理完後手動清空
global_data = []  # 釋放內存

更好的做法是儘量用局部變量，函數執行結束後局部變量會被自動回收。

三、內存優化實用技巧

1. 用 sys.getrefcount 查看引用計數

調試時可以檢查對象的引用計數，找出意外的引用：

import sys

a = [1, 2, 3]
print(sys.getrefcount(a))  # 輸出 2（變量a和getrefcount的參數各算一個）

b = a
print(sys.getrefcount(a))  # 輸出 3

2. 用 gc 模塊手動控制垃圾回收

必要時可以手動觸發垃圾回收或查看回收信息：

import gc

# 查看當前未回收的對象數
print(f"未回收對象數：{len(gc.get_objects())}")

# 手動觸發垃圾回收
collected = gc.collect()
print(f"回收了 {collected} 個對象")

# 開啓循環引用調試（開發環境用）
gc.set_debug(gc.DEBUG_SAVEALL)  # 回收的對象會保存到 gc.garbage

3. 選擇更高效的數據結構

  • 用 array.array 存儲同類型數據，比列表更節省內存
  • 用 collections.namedtuple 代替類存儲簡單數據
  • 用 Pandas 處理大型表格數據（內部優化了內存使用）
import array

# 存儲100萬個整數，用array比list節省約一半內存
int_list = [i for i in range(1_000_000)]
int_array = array.array('i', range(1_000_000))  # 'i' 表示int類型

4. 及時關閉資源

文件、網絡連接等資源雖然不是 Python 對象，但未關閉可能導致句柄泄漏，間接影響內存：

# 不好的寫法：可能忘記關閉文件
f = open('big_file.txt', 'r')
data = f.read()
# 處理數據...
# 忘記 f.close()

# 好的寫法：用with語句自動關閉
with open('big_file.txt', 'r') as f:
    data = f.read()
# 離開with塊後自動關閉，即使發生異常

四、避坑指南

  1. 不要過度依賴自動回收：雖然 Python 會自動回收內存，但對於長期運行的程序（如服務器），仍需定期檢查內存使用情況。
  2. 謹慎使用裝飾器和閉包：閉包可能會意外持有外部變量的引用，導致對象無法回收：
def outer():
    big_list = [1] * 10000  # 大對象
    
    def inner():
        # 即使沒使用 big_list，閉包也可能持有引用（取決於Python版本）
        return "hello"
    
    return inner

# 調用後 big_list 本應被回收，但可能被 inner 持有引用
func = outer()
  1. 注意第三方庫的內存泄漏：有些 C 擴展庫可能存在內存泄漏（不會被 Python 垃圾回收機制處理），遇到這種情況可以嘗試升級庫或更換替代品。
  2. 避免在循環中創建大量臨時對象：循環中頻繁創建對象會觸發頻繁的垃圾回收，影響性能：
# 不好的寫法：每次循環創建新列表
for _ in range(10000):
    temp = [1, 2, 3]  # 每次迭代創建新對象
    process(temp)

# 好的寫法：複用對象
temp = [1, 2, 3]
for _ in range(10000):
    process(temp)  # 複用同一個對象

總結

Python 的垃圾回收機制降低了內存管理的門檻，但瞭解其原理（引用計數、標記-清除、分代回收）能幫我們寫出更高效的代碼。實際開發中，要特別注意循環引用、全局變量和大對象的內存使用，善用生成器、弱引用等工具優化內存。

記住，內存優化的關鍵不是“榨乾每一個字節”，而是避免不必要的浪費。大多數時候，保持良好的編程習慣（如及時清理不再使用的變量、用 with 語句管理資源）就能避免大部分內存問題。當程序出現內存異常時，再針對性地分析和優化，這才是高效的做法。