Python 採用引用語義:變量是貼在對象上的標籤,而非裝值的盒子。理解三層關係是掌握拷貝的鑰匙:
變量 (引用) ──指向──→ 對象 (內存實體)
│ │
│ ┌───────┴───────┐
│ ▼ ▼
│ 可變對象 不可變對象
│ (list, dict, set) (int, str, tuple)
│ │ │
└──────────────┴───────────────┘
賦值 = 複製引用 (共享對象)
a = [1, 2, 3]
b = a # b 指向同一列表對象
b[0] = 99
print(a) # [99, 2, 3] ← a 也變了!
print(a is b) # True,同一對象
import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original) # 或 original[:], list(original)
shallow[0][0] = 99 # 修改嵌套元素
print(original) # [[99, 2], [3, 4]] ← 原對象受影響!
print(shallow) # [[99, 2], [3, 4]]
適用:一維列表、無嵌套結構、頂層元素為不可變對象
deep = copy.deepcopy(original)
deep[0][0] = 88
print(original) # [[1, 2], [3, 4]] ← 完全隔離
print(deep) # [[88, 2], [3, 4]]
lst = [1, 2, [3, 4]]
sliced = lst[:] # 淺拷貝!
sliced[2][0] = 99
print(lst) # [1, 2, [99, 4]] ← 嵌套列表共享
.copy() = 淺拷貝.copy() = 淺拷貝
原對象: [A, B, C] 其中 B = [x, y] (嵌套列表)
賦值: ref ──────→ [A, B, C] (同一對象)
淺拷貝: 新對象 ──→ [A, B, C] (新頂層列表)
│ │ │
▼ ▼ ▼
[A] [B] [C] (B 仍共享!)
深拷貝: 新對象 ──→ [A, B', C] (完全獨立)
│ │ │
▼ ▼ ▼
[A] [B'] [C] (B' 為新複製)
# 字典
d = {'a': [1,2], 'b': [3,4]}
d_shallow = d.copy() # 或 dict(d), {**d}
d_deep = copy.deepcopy(d)
# 集合
s = {1, 2, frozenset([3,4])}
s_shallow = s.copy() # 或 set(s), {*s}
s_deep = copy.deepcopy(s)
# 不可變對象「拷貝」無意義,返回自身
t = (1, 2, 3)
print(copy.copy(t) is t) # True
print(copy.deepcopy(t) is t) # True
# 但包含可變元素的元組會深拷貝
t2 = (1, [2, 3])
print(copy.deepcopy(t2) is t2) # False
| 場景 | 推薦方式 | 時間複雜度 |
|---|---|---|
| 一維不可變元素列表 | lst[:] / list(lst) | O(n) |
| 嵌套結構需完全隔離 | copy.deepcopy() | O(n) 含遞歸開銷 |
| 頂層隔離即可 | copy.copy() / lst[:] | O(n) |
| 大對象頻繁拷貝 | 考慮不可變數據結構 / 結構共享 | - |
def bad_func(items=[]): # 列表在定義時創建一次,共享!
items.append(1)
return items
def good_func(items=None):
if items is None:
items = []
items.append(1)
return items
copy.deepcopy 內部用 memo 字典處理,但極深嵌套仍可能遞歸溢出__copy__、__deepcopy__ 方法自定義行為徹底理解「變量引用對象」模型,拷貝行為就不再神秘。根據數據結構特點選擇正確拷貝策略,是編寫健壯 Python 代碼的關鍵。