萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> 程式語言綜合

Python 深拷貝與淺拷貝徹底解析:變量-對象-引用模型圖解

核心概念模型

Python 採用引用語義:變量是貼在對象上的標籤,而非裝值的盒子。理解三層關係是掌握拷貝的鑰匙:

變量 (引用) ──指向──→ 對象 (內存實體)
     │                      │
     │              ┌───────┴───────┐
     │              ▼               ▼
     │         可變對象          不可變對象
     │      (list, dict, set)    (int, str, tuple)
     │              │               │
     └──────────────┴───────────────┘
                    賦值 = 複製引用 (共享對象)

賦值 vs 淺拷貝 vs 深拷貝

1. 賦值 (=) — 共享引用


a = [1, 2, 3]
b = a           # b 指向同一列表對象
b[0] = 99
print(a)        # [99, 2, 3] ← a 也變了!
print(a is b)   # True,同一對象

2. 淺拷貝 — 複製頂層,嵌套仍共享


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]]

適用:一維列表、無嵌套結構、頂層元素為不可變對象

3. 深拷貝 — 遞歸複製所有層級


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]] ← 嵌套列表共享
  • 序列切片(list/str/tuple)= 淺拷貝
  • 字典 .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)
大對象頻繁拷貝考慮不可變數據結構 / 結構共享-

常見坑點避雷

  1. 函數默認參數陷阱:
    
    def bad_func(items=[]):  # 列表在定義時創建一次,共享!
        items.append(1)
        return items
    
    def good_func(items=None):
        if items is None:
            items = []
        items.append(1)
        return items
    
  2. 循環引用導致 deepcopy 遞歸爆棧:copy.deepcopy 內部用 memo 字典處理,但極深嵌套仍可能遞歸溢出
  3. 自定義類拷貝控制:實現 __copy__、__deepcopy__ 方法自定義行為

徹底理解「變量引用對象」模型,拷貝行為就不再神秘。根據數據結構特點選擇正確拷貝策略,是編寫健壯 Python 代碼的關鍵。

copyright © 萬盛學電腦網 all rights reserved