通過代碼和結果來理解淺拷貝和深度拷貝，先來看看python中有那些常見的淺拷貝方法：

1.使用數據類型本身的構造器：

            
              l1 = [1,2,3]
l2 = list(l1)

l1 == l2 #True
l1 is l2 #False

#l2就是l1的淺拷貝,set、dict與上面的淺拷貝一致


t1 = (1,2,3)
t2 = tuple(t1)

t1 == t2 #True
t1 is t2 #True

#由于tuple不可變，tuple返回一個指向相同元組的引用，與list、set、dict不一樣


            
          

2.通過切片操作符‘:’完成淺拷貝：

            
              l1 = [1, 2, 3]
l2 = l1[:]

l1 == l2 #True

l1 is l2 #False

            
          

3.python中提供的函數copy.copy()，適用于任何數據類型：

            
              import copy
l1 = [1, 2, 3]
l2 = copy.copy(l1)

l1 == l2 #True
l1 is l2 #False
            
          

淺拷貝，是指重新分配一塊內存，創建一個新對象，里面的元素是原對象中子對象的引用。如果元素可變（list、set、dict），淺拷貝會帶來一些副作用。如果元素不可變（Number、String、Tuple），就沒有這些副作用。

            
              l1 = [[1, 2], (30, 40)]
l2 = list(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2
[[1, 2, 3], (30, 40)]

l1[1] += (50, 60)
l1
[[1, 2, 3], (30, 40, 50, 60), 100]

l2
[[1, 2, 3], (30, 40)]

            
          

根據以上代碼，初始化了一個列表l1，里面的元素是一個列表和一個元組；,l2是l1的淺拷貝，l2中的元素和l1指向同一個列表和元組對象。

1. 當l1.append(100)，新增元素100。這個操作不會對l2產生任何影響，因為l2和l1作為整體是兩個不同的對象，并不共享內存地址。
2. 執行l1[0].append(3)，對l1的列表新增元素3。由于l2是l1的淺拷貝，l2的第一個元素和l1中的第一個元素，共同指向同一個列表，因此l2中的第一個列表也會相對應的新增元素3。l2也跟著發生改變。
3. 操作l1[1] += (50,60)，因為元祖是不可變的，這里表示對l1中的元組拼接，實際上是重新創建了一個新元組作為l1中的第二個元素，而l2中沒有引用新元組，l2并不受影響。

通過以上代碼，可以很清楚的看到使用淺拷貝的副作用。

總結下，如果集合中有list、set、dict（可變類型）任意一個，慎重使用淺拷貝；如果集合中元素只有Number、String、Tuple（不可變元素），使用淺拷貝，就沒有副作用。

要避免這種副作用，完整的拷貝一個對象，就得使用深度拷貝。是指重新分配一塊內存，創建一個新對象，并且將原對象中的元素，以遞歸的方式，通過創建新的子對象拷貝到新對象中。因此，新對象和原對象沒有任何關聯。

python中以copy.deepcopy()來實現對象的深度拷貝。

            
              import copy
l1 = [[1, 2], (30, 40)]
l2 = copy.deepcopy(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2 
[[1, 2], (30, 40)]
            
          

?