[Python3 填坑] 009 深拷貝與淺拷貝

阿新 • • 發佈：2019-01-27

[1] 創建官方文檔包含 lan 賬號引用新的官方

1. print( 坑的信息 )
2. 開始填坑
- (1) 問題描述
- (2) Python3.7.2 官方文檔
- (3) 先說結論
  - 1) 復合對象談深拷貝與淺拷貝的區別才有意義
  - 2) 深拷貝常伴隨兩個問題，而淺拷貝對此無需擔心
  - 3) deepcopy() 通過以下方式避免 2) 的問題：
  - 4) 補充
- (4) 少廢話，上例子
- (5) 召喚深拷貝
- (6) 關於不可變元素

1. print( 坑的信息 )

挖坑時間：2019/01/10
明細

坑的編碼	內容
Py006-3	Python3 中的深拷貝與淺拷貝

2. 開始填坑

(1) 問題描述

個人覺得深拷貝與淺拷貝裏面大有文章，此篇隨筆只能算是淺談。

(2) Python3.7.2 官方文檔

文檔地址
源碼地址

(3) 先說結論

描述“深拷貝與“淺拷貝”時，常與“賦值”進行對比
簡單地說
- 賦值，就像給原對象取個昵稱，無論呼本名還是喚昵稱，說的都是同一個事物
- 深拷貝，拷貝的是原對象內部的元素，拷貝後井水不犯河水，是一個真正的副本
- 淺拷貝，拷貝的是原對象內部數據的地址，拷貝後藕斷絲連，並不是一個真正的副本
淺拷貝的補充
- 拷貝後的新對象占用新的空間，但其內部的元素指向原對象內部對應元素的地址
- 當原對象中的可變元素發生變化時，新對象中的對應元素同步變化
- 當原對象中的不可變元素重新生成時，新對象中的對應元素保持不變
- 只拷貝第一層元素，有人稱其為“頂層拷貝”
- 在前期做一個淺拷貝可以防止後期因變量名眾多而混亂
- 可應用於“聯合賬號”等

對 copy 模塊而言

1) 復合對象談深拷貝與淺拷貝的區別才有意義

復合對象：包含其他對象的對象，如列表、類實例等
深拷貝會構造一個新的復合對象，然後遞歸地將在原始對象中所有元素的副本對應地寫入新復合對象中
淺拷貝會構造一個新的復合對象，然後（在允許的前提下）向其中寫入對原始對象的引用

2) 深拷貝常伴隨兩個問題，而淺拷貝對此無需擔心

遞歸對象（直接或間接包含對自身引用的復合對象）可能導致遞歸循環
因為深拷貝會復制原對象的一切，所以可能復制過多的內容，例如打算在副本之間共享的數據

3) deepcopy() 通過以下方式避免 2) 的問題：

保存在當前復制過程中已經復制的對象的 memo 字典
讓用戶定義的類重寫復制操作或復制的組件集

4) 補充

它不能拷貝模塊、方法、堆棧跟蹤、堆棧幀、文件、套接字、窗口、數組等
可以重寫 copy.copy(x) 和 copy.deepcopy(x[, memo])

(4) 少廢話，上例子

對於可變或包含可變項的容器，有時需要一個可以在不破壞其它容器的情況下更改自身的副本。

# 例1 從對象的地址上看

list1_1 = [1, 2, 3, 4, 5]
list1_2 = list1_1           # Python 中的賦值語句不復制對象，它們會在目標和對象之間創建綁定關系
list1_3 = list1_1[:]        # 通過分配整個列表的切片來制作列表的淺拷貝
list1_4 = list1_1.copy()    # 使用 list.copy() 來制作列表的淺拷貝
                            # 同理，可以使用 dict.copy() 來制作字典的淺拷貝

print("list1_1 =", list1_1)
print("list1_2 =", list1_2)
print("list1_3 =", list1_3)
print("list1_4 =", list1_4)
print(‘-‘*30)

print("id(list1_1) =", id(list1_1))
print("id(list1_2) =", id(list1_2))
print("id(list1_3) =", id(list1_3))
print("id(list1_4) =", id(list1_4))

運行結果

list1_1 = [1, 2, 3, 4, 5]
list1_2 = [1, 2, 3, 4, 5]
list1_3 = [1, 2, 3, 4, 5]
list1_4 = [1, 2, 3, 4, 5]
------------------------------
id(list1_1) = 1790322044808
id(list1_2) = 1790322044808
id(list1_3) = 1790321996744
id(list1_4) = 1790321982024

# 例2 從對象的元素上看（我可能有些啰嗦了）

list2_1 = [1, 2, 3, 4, 5]
list2_2 = list2_1           # 賦值
list2_3 = list2_1[:]        # 淺拷貝
list2_4 = list2_1.copy()    # 淺拷貝

print("list2_1 =", list2_1)
print("list2_2 =", list2_2)
print("list2_3 =", list2_3)
print("list2_4 =", list2_4)
print(‘-‘*30)

list2_1[0] = 661
print("* list2_1 =", list2_1)
print("* list2_2 =", list2_2)
print("* list2_3 =", list2_3)
print("* list2_4 =", list2_4)
print(‘-‘*30)

list2_2[1] = 662
print("* list2_1‘ =", list2_1)
print("* list2_2‘ =", list2_2)
print("* list2_3‘ =", list2_3)
print("* list2_4‘ =", list2_4)
print(‘-‘*30)

list2_3[2] = 663
print("* list2_1‘‘ =", list2_1)
print("* list2_2‘‘ =", list2_2)
print("* list2_3‘‘ =", list2_3)
print("* list2_4‘‘ =", list2_4)
print(‘-‘*30)

list2_4[3] = 664
print("* list2_1‘‘‘ =", list2_1)
print("* list2_2‘‘‘ =", list2_2)
print("* list2_3‘‘‘ =", list2_3)
print("* list2_4‘‘‘ =", list2_4)

運行結果

list2_1 = [1, 2, 3, 4, 5]
list2_2 = [1, 2, 3, 4, 5]
list2_3 = [1, 2, 3, 4, 5]
list2_4 = [1, 2, 3, 4, 5]
------------------------------
* list2_1 = [661, 2, 3, 4, 5]
* list2_2 = [661, 2, 3, 4, 5]
* list2_3 = [1, 2, 3, 4, 5]
* list2_4 = [1, 2, 3, 4, 5]
------------------------------
* list2_1‘ = [661, 662, 3, 4, 5]
* list2_2‘ = [661, 662, 3, 4, 5]
* list2_3‘ = [1, 2, 3, 4, 5]
* list2_4‘ = [1, 2, 3, 4, 5]
------------------------------
* list2_1‘‘ = [661, 662, 3, 4, 5]
* list2_2‘‘ = [661, 662, 3, 4, 5]
* list2_3‘‘ = [1, 2, 663, 4, 5]
* list2_4‘‘ = [1, 2, 3, 4, 5]
------------------------------
* list2_1‘‘‘ = [661, 662, 3, 4, 5]
* list2_2‘‘‘ = [661, 662, 3, 4, 5]
* list2_3‘‘‘ = [1, 2, 663, 4, 5]
* list2_4‘‘‘ = [1, 2, 3, 664, 5]

# 例3 從元素的地址上看

list3_1 = [0, 1, 2, [3, 4, 5]]
list3_2 = list3_1               # 賦值
list3_3 = list3_1[:]            # 淺拷貝
list3_4 = list3_1.copy()        # 淺拷貝

print("list3_1 =", list3_1)
print("list3_2 =", list3_2)
print("list3_3 =", list3_3)
print("list3_4 =", list3_4)
print(‘-‘*30)

print("id(list3_1[0]) =", id(list3_1[0]))
print("id(list3_2[0]) =", id(list3_2[0]))
print("id(list3_3[0]) =", id(list3_3[0]))
print("id(list3_4[0]) =", id(list3_4[0]))
print(‘-‘*30)

print("id(list3_1[3]) =", id(list3_1[3]))
print("id(list3_2[3]) =", id(list3_2[3]))
print("id(list3_3[3]) =", id(list3_3[3]))
print("id(list3_4[3]) =", id(list3_4[3]))
print(‘-‘*30)

print("id(list3_1[3][0]) =", id(list3_1[3][0]))
print("id(list3_2[3][0]) =", id(list3_2[3][0]))
print("id(list3_3[3][0]) =", id(list3_3[3][0]))
print("id(list3_4[3][0]) =", id(list3_4[3][0]))

運行結果

list3_1 = [0, 1, 2, [3, 4, 5]]
list3_2 = [0, 1, 2, [3, 4, 5]]
list3_3 = [0, 1, 2, [3, 4, 5]]
list3_4 = [0, 1, 2, [3, 4, 5]]
------------------------------
id(list3_1[0]) = 140720367595232
id(list3_2[0]) = 140720367595232
id(list3_3[0]) = 140720367595232
id(list3_4[0]) = 140720367595232
------------------------------
id(list3_1[3]) = 2859246390984
id(list3_2[3]) = 2859246390984
id(list3_3[3]) = 2859246390984
id(list3_4[3]) = 2859246390984
------------------------------
id(list3_1[3][0]) = 140720367595328
id(list3_2[3][0]) = 140720367595328
id(list3_3[3][0]) = 140720367595328
id(list3_4[3][0]) = 140720367595328

# 例4.1 關於層數（第 2 層）

list4_1 = [0, 1, 2, [3, 4, 5]]
list4_2 = list4_1
list4_3 = list4_1[:]
list4_4 = list4_1.copy()

print("list4_1 =", list4_1)
print("list4_2 =", list4_2)
print("list4_3 =", list4_3)
print("list4_4 =", list4_4)
print(‘-‘*30)

list4_1[3].append(6)
print("* list4_1 =", list4_1)
print("* list4_2 =", list4_2)
print("* list4_3 =", list4_3)
print("* list4_4 =", list4_4)
print(‘-‘*30)

list4_2[3].append(7)
print("* list4_1‘ =", list4_1)
print("* list4_2‘ =", list4_2)
print("* list4_3‘ =", list4_3)
print("* list4_4‘ =", list4_4)
print(‘-‘*30)

list4_3[3][0] = 666
print("* list4_1‘‘ =", list4_1)
print("* list4_2‘‘ =", list4_2)
print("* list4_3‘‘ =", list4_3)
print("* list4_4‘‘ =", list4_4)
print(‘-‘*30)

list4_4[3][1] = 888
print("* list4_1‘‘‘ =", list4_1)
print("* list4_2‘‘‘ =", list4_2)
print("* list4_3‘‘‘ =", list4_3)
print("* list4_4‘‘‘ =", list4_4)

運行結果

list4_1 = [0, 1, 2, [3, 4, 5]]
list4_2 = [0, 1, 2, [3, 4, 5]]
list4_3 = [0, 1, 2, [3, 4, 5]]
list4_4 = [0, 1, 2, [3, 4, 5]]
------------------------------
* list4_1 = [0, 1, 2, [3, 4, 5, 6]]
* list4_2 = [0, 1, 2, [3, 4, 5, 6]]
* list4_3 = [0, 1, 2, [3, 4, 5, 6]]
* list4_4 = [0, 1, 2, [3, 4, 5, 6]]
------------------------------
* list4_1‘ = [0, 1, 2, [3, 4, 5, 6, 7]]
* list4_2‘ = [0, 1, 2, [3, 4, 5, 6, 7]]
* list4_3‘ = [0, 1, 2, [3, 4, 5, 6, 7]]
* list4_4‘ = [0, 1, 2, [3, 4, 5, 6, 7]]
------------------------------
* list4_1‘‘ = [0, 1, 2, [666, 4, 5, 6, 7]]
* list4_2‘‘ = [0, 1, 2, [666, 4, 5, 6, 7]]
* list4_3‘‘ = [0, 1, 2, [666, 4, 5, 6, 7]]
* list4_4‘‘ = [0, 1, 2, [666, 4, 5, 6, 7]]
------------------------------
* list4_1‘‘‘ = [0, 1, 2, [666, 888, 5, 6, 7]]
* list4_2‘‘‘ = [0, 1, 2, [666, 888, 5, 6, 7]]
* list4_3‘‘‘ = [0, 1, 2, [666, 888, 5, 6, 7]]
* list4_4‘‘‘ = [0, 1, 2, [666, 888, 5, 6, 7]]

從例3 的 id 也不難想象這個結果。

# 例4.2 關於層數（第 1 層；我啰嗦了，此例同例2）

list4_1 = [0, 1, 2, [3, 4, 5]]
list4_2 = list4_1
list4_3 = list4_1[:]
list4_4 = list4_1.copy()

print("list4_1 =", list4_1)
print("list4_2 =", list4_2)
print("list4_3 =", list4_3)
print("list4_4 =", list4_4)
print(‘-‘*50)

list4_1.append(6)
print("* list4_1 =", list4_1)
print("* list4_2 =", list4_2)
print("* list4_3 =", list4_3)
print("* list4_4 =", list4_4)
print(‘-‘*50)

list4_2.extend([7, 8])
print("* list4_1‘ =", list4_1)
print("* list4_2‘ =", list4_2)
print("* list4_3‘ =", list4_3)
print("* list4_4‘ =", list4_4)
print(‘-‘*50)

list4_3.insert(3, "YorkFish")
print("* list4_1‘‘ =", list4_1)
print("* list4_2‘‘ =", list4_2)
print("* list4_3‘‘ =", list4_3)
print("* list4_4‘‘ =", list4_4)
print(‘-‘*50)

list4_4.insert(0, "YorkFish")
print("* list4_1‘‘‘ =", list4_1)
print("* list4_2‘‘‘ =", list4_2)
print("* list4_3‘‘‘ =", list4_3)
print("* list4_4‘‘‘ =", list4_4)

運行結果

list4_1 = [0, 1, 2, [3, 4, 5]]
list4_2 = [0, 1, 2, [3, 4, 5]]
list4_3 = [0, 1, 2, [3, 4, 5]]
list4_4 = [0, 1, 2, [3, 4, 5]]
--------------------------------------------------
* list4_1 = [0, 1, 2, [3, 4, 5], 6]
* list4_2 = [0, 1, 2, [3, 4, 5], 6]
* list4_3 = [0, 1, 2, [3, 4, 5]]
* list4_4 = [0, 1, 2, [3, 4, 5]]
--------------------------------------------------
* list4_1‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_2‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_3‘ = [0, 1, 2, [3, 4, 5]]
* list4_4‘ = [0, 1, 2, [3, 4, 5]]
--------------------------------------------------
* list4_1‘‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_2‘‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_3‘‘ = [0, 1, 2, ‘YorkFish‘, [3, 4, 5]]
* list4_4‘‘ = [0, 1, 2, [3, 4, 5]]
--------------------------------------------------
* list4_1‘‘‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_2‘‘‘ = [0, 1, 2, [3, 4, 5], 6, 7, 8]
* list4_3‘‘‘ = [0, 1, 2, ‘YorkFish‘, [3, 4, 5]]
* list4_4‘‘‘ = [‘YorkFish‘, 0, 1, 2, [3, 4, 5]]

(5) 召喚深拷貝

# 例5 賦值與淺拷貝、深拷貝的不同

import copy     # 導入 copy 模塊

list5_1 = [0, 1, 2, [‘a‘, ‘b‘]]
list5_2 = list5_1                   # 賦值
list5_3 = list5_1.copy()            # 淺拷貝;用 list5_1[:] 效果一樣
list5_4 = copy.copy(list5_1)        # 淺拷貝
list5_5 = copy.deepcopy(list5_1)    # 遲來的深拷貝

print("list5_1 =", list5_1)
print("list5_2 =", list5_2)
print("list5_3 =", list5_3)
print("list5_4 =", list5_4)
print("list5_5 =", list5_5)
print(‘-‘*30)

list5_1.append(4)
list5_1[3].append(‘c‘)
print("list5_1‘ =", list5_1)
print("list5_2‘ =", list5_2)
print("list5_3‘ =", list5_3)
print("list5_4‘ =", list5_4)
print("list5_5‘ =", list5_5)

運行結果

list5_1 = [0, 1, 2, [‘a‘, ‘b‘]]
list5_2 = [0, 1, 2, [‘a‘, ‘b‘]]
list5_3 = [0, 1, 2, [‘a‘, ‘b‘]]
list5_4 = [0, 1, 2, [‘a‘, ‘b‘]]
list5_5 = [0, 1, 2, [‘a‘, ‘b‘]]
------------------------------
list5_1‘ = [0, 1, 2, [‘a‘, ‘b‘, ‘c‘], 4]
list5_2‘ = [0, 1, 2, [‘a‘, ‘b‘, ‘c‘], 4]
list5_3‘ = [0, 1, 2, [‘a‘, ‘b‘, ‘c‘]]
list5_4‘ = [0, 1, 2, [‘a‘, ‘b‘, ‘c‘]]
list5_5‘ = [0, 1, 2, [‘a‘, ‘b‘]]

深拷貝的第二層沒有像淺拷貝一樣隨原對象的變化而變化。

(6) 關於不可變元素

# 例6 “不動如山”的不可變元素

import copy

list6_1 = [0, 1, 2, (3, 4, 5)]
list6_2 = list6_1
list6_3 = list6_1.copy()        # 用 list6_1[:] 效果一樣
list6_4 = copy.copy(list6_1)
list6_5 = copy.deepcopy(list6_1)

print("list6_1 =", list6_1)
print("list6_2 =", list6_2)
print("list6_3 =", list6_3)
print("list6_4 =", list6_4)
print("list6_5 =", list6_5)
print(‘-‘*30)

print("id(ist6_1[3]) =", id(list6_1[3]))
print("id(ist6_2[3]) =", id(list6_2[3]))
print("id(ist6_3[3]) =", id(list6_3[3]))
print("id(ist6_4[3]) =", id(list6_4[3]))
print("id(ist6_5[3]) =", id(list6_5[3]))
print(‘-‘*30)

list6_1[3] = (6, 6, 6)          # list6_1 與 list6_2 是一體的
print("list6_1‘ =", list6_1)
print("list6_2‘ =", list6_2)
print("list6_3‘ =", list6_3)
print("list6_4‘ =", list6_4)
print("list6_5‘ =", list6_5)
print(‘-‘*30)

print("id(ist6_1[3]‘) =", id(list6_1[3]))
print("id(ist6_2[3]‘) =", id(list6_2[3]))
print("id(ist6_3[3]‘) =", id(list6_3[3]))
print("id(ist6_4[3]‘) =", id(list6_4[3]))
print("id(ist6_5[3]‘) =", id(list6_5[3]))
print(‘-‘*30)

list6_2[3] = (8, 8, 8)
list6_3[3] = (8, 8, 8)
list6_4[3] = (8, 8, 8)
list6_5[3] = (8, 8, 8)
print("list6_1‘‘ =", list6_1)
print("list6_2‘‘ =", list6_2)
print("list6_3‘‘ =", list6_3)
print("list6_4‘‘ =", list6_4)
print("list6_5‘‘ =", list6_5)
print(‘-‘*30)

print("id(ist6_1[3]‘‘) =", id(list6_1[3]))
print("id(ist6_2[3]‘‘) =", id(list6_2[3]))
print("id(ist6_3[3]‘‘) =", id(list6_3[3]))  # 註意 id
print("id(ist6_4[3]‘‘) =", id(list6_4[3]))  # 註意 id
print("id(ist6_5[3]‘‘) =", id(list6_5[3]))  # 註意 id

運行結果

list6_1 = [0, 1, 2, (3, 4, 5)]
list6_2 = [0, 1, 2, (3, 4, 5)]
list6_3 = [0, 1, 2, (3, 4, 5)]
list6_4 = [0, 1, 2, (3, 4, 5)]
list6_5 = [0, 1, 2, (3, 4, 5)]
------------------------------
id(ist6_1[3]) = 2683399214208
id(ist6_2[3]) = 2683399214208
id(ist6_3[3]) = 2683399214208
id(ist6_4[3]) = 2683399214208
------------------------------
list6_1‘ = [0, 1, 2, (6, 6, 6)]
list6_2‘ = [0, 1, 2, (6, 6, 6)]
list6_3‘ = [0, 1, 2, (3, 4, 5)]
list6_4‘ = [0, 1, 2, (3, 4, 5)]
list6_5‘ = [0, 1, 2, (3, 4, 5)]
------------------------------
id(ist6_1[3]‘) = 2683399759624
id(ist6_2[3]‘) = 2683399759624
id(ist6_3[3]‘) = 2683399214208
id(ist6_4[3]‘) = 2683399214208
id(ist6_5[3]‘) = 2683399214208
------------------------------
list6_1‘‘ = [0, 1, 2, (8, 8, 8)]
list6_2‘‘ = [0, 1, 2, (8, 8, 8)]
list6_3‘‘ = [0, 1, 2, (8, 8, 8)]
list6_4‘‘ = [0, 1, 2, (8, 8, 8)]
list6_5‘‘ = [0, 1, 2, (8, 8, 8)]
------------------------------
id(ist6_1[3]‘‘) = 2683399916856
id(ist6_2[3]‘‘) = 2683399916856
id(ist6_3[3]‘‘) = 2683399968520
id(ist6_4[3]‘‘) = 2683399759624
id(ist6_5[3]‘‘) = 2683399921880

Python3 能“偷懶”時必“偷懶”，對於可變元素，有變化才分配新地址。

在下學識有限，不足之處，還請諸位多多指教！

[Python3 填坑] 009 深拷貝與淺拷貝

[1] 創建官方文檔包含 lan 賬號引用新的官方目錄 1. print( 坑的信息 ) 2. 開始填坑 (1) 問題描述 (2) Python3.7.2 官方文檔 (3) 先說結論 1) 復合對象談深拷貝與淺拷貝的區別才有意義 2) 深拷貝常伴隨兩個問題，而

python3 深拷貝與淺拷貝的思考和應用 --cool_soup29的學習筆記

深拷貝和淺拷貝是什麼？大致理解，a = 1,b = a,淺拷貝，改變b,a隨之改變。深拷貝，a = 1 ,b = copy.deepcopy(a), a不會隨著b的改變而改變。更深層次的理解，則是變數是否繫結的物件的ip地址是否一致。定義什麼的就不在此闡

[隨筆重寫] Python3 的深拷貝與淺拷貝

發生 deep 同步所有副本拷貝 python .py 不可變 1. Python3 關於深淺拷貝的官方文檔文檔地址：Python3.7.2 源碼地址：lib/copy.py 2. 先說結論深拷貝與淺拷貝是對復合對象而言的深拷貝會構造一個新的復合對象，然後

C#深度學習の----深拷貝與淺拷貝

chan 深度保存交流 typeof sta 二進制 object with 本人在進行編程的時候遇到一個問題，要對一個綁定的依賴屬性進行賦值，改變屬性中的某一部分，綁定的目標上的所有值都發生了變化，著並不是我想要的，由此引出深淺拷貝的問題。（請加群交流：4352266

javaScript之深拷貝與淺拷貝

func array efi name 內存空間數據 xtend 是否 -- js中有兩種數據類型： 1. 基本類型： Number、String、Boolean、Null、Undefined 2. 復雜類型： Object 、Ar

c++分文件定義深拷貝與淺拷貝

淺拷貝1、#include <stdlib.h> #include <iostream> #include "Array.h" using namespace std; int main(void) { Array arr1; arr1.setCount(5); Array

字典的深拷貝與淺拷貝

/usr odin pri 修改 hal sha deepcopy data str 以前只知道用dict2 = dict1 來進行復制（備份），結果發現對dict2做增刪改等操作時，dict1也會隨之變化，反過來也這樣。沒有好好學習基礎的我，自然在這裏面吃了不少的虧。。。

iOS 圖文並茂的帶你了解深拷貝與淺拷貝

mstr ear span ini 5.7 [1] ring void 結束一、概念與總結 1、淺拷貝淺拷貝就是對內存地址的復制，讓目標對象指針和源對象指向同一片內存空間，當內存銷毀的時候，指向這片內存的幾個指針需要重新定義才可以使用，要不然會成為野

Python中深拷貝與淺拷貝區別

分配 img 地址 append 淺拷貝 pen image pre 內容淺拷貝， list值是可變的，str值不可變，只能重新賦值 a=b=c=‘wjx‘print(a,b,c)c= ‘jmy‘#重新賦值了，所以內存分配了新的地址print(a,b,c)print(id

python:深拷貝與淺拷貝

pri 復制空間 epc python import ams post name import copyname = ["sams", ["su", "ca"]]name0 = name#直接復制，指向同一內存空間name1 = copy.copy(name)#淺拷貝，也

python list的深拷貝與淺拷貝-以及初始化空白list的方法(2)

src 分享圖片 [1] 深拷貝 pen net .com 空白 tails 其實python對於深拷貝與淺拷貝的處理方式依然是很靈活的，甚至有一個專門的工具包copy來做個事情來看以下這組list的拷貝方法：已知lista是一個已經定義好了的list listb=l

深拷貝與淺拷貝

post false 所有 console oda 嵌套 lod cti 屬性。淺拷貝對於基本類型，淺拷貝是對值的復制，對於對象來說，淺拷貝只復制指向某個對象的指針，而不復制對象本身，並沒有開辟新的棧，也就是復制的結果是新舊對象還是共享同一塊內存，兩個對象指向同一個地址

js中的深拷貝與淺拷貝

nbsp 中一局限性深拷貝與淺拷貝 ext bsp post body extend 對於字符串類型，淺拷貝是對值的拷貝，對於對象來說，淺拷貝是對對象地址的拷貝，並沒有開辟新的棧，也就是拷貝的結果是兩個對象指向同一個地址，修改其中一個對象的屬性，則另一個對象的屬性也會改

JavaScript深拷貝與淺拷貝

javascript深拷貝與淺拷貝1.先看一個例子：從中可以看出，obj1拷貝了obj的值，但只是進行了地址的引用，修改obj1的值也影響到了obj的值，沒有創建新對象。淺拷貝：對基本數據類型進行值傳遞，對引用數據類型進行引用傳遞般的拷貝。深拷貝：對基本數據類型進行值傳遞，對引用數據類型，創建一個新的對象

python 的深拷貝與淺拷貝

bsp 分享 ima 都是跟著 class 淺拷貝和深拷貝分享圖片 src 一句話總結，淺拷貝只拷貝父對象，不拷貝子對像。註意：淺拷貝和深拷貝的不同僅僅是對組合對象來說，所謂的組合對象就是包含了其它對象的對象，如列表，類實例。而對於數字、字符串以及其它“原子”類型，沒

ES6深拷貝與淺拷貝

olt 常用依次基本對象 cnblogs 復制過程數據 JavaScript 中變量的賦值結論：JavaScript中變量的賦值分為「傳值」與「傳址」。基本數據類型的賦值，就是「傳值」；而引用類型變量賦值，實際上是「傳址」。基本數據類型變量的賦值、比較，只是值

列表操作 -深拷貝與淺拷貝

col -c int 文件命名 odin ubi spa csdn 沖突轉自: https://blog.csdn.net/dengwubin450/article/details/57980514 1.淺拷貝（copy），深拷貝 1.1 淺拷貝 # coding:ut

深拷貝與淺拷貝詳解

RoCE 深拷貝 tps sys 實現 java 圖片 public 動態　　在講解深拷貝與淺拷貝講解之前，需要先弄懂拷貝的分類：引用拷貝和對象拷貝。　　　　註：深拷貝和淺拷貝都是對象拷貝 1.拷貝的引入（1）引用拷貝創建一個指向對象的引用變量的拷貝。例1

Python中list的復制及深拷貝與淺拷貝探究

python3 接下來 after mic 怎樣 tro 重要技術循環　　在Python中，經常要對一個list進行復制。對於復制，自然的就有深拷貝與淺拷貝問題。深拷貝與淺拷貝的區別在於，當從原本的list復制出新的list之後，修改其中的任意一個是否會對另一個造成影

【JS】深拷貝與淺拷貝的區別，實現深拷貝的幾種方法

如何區分深拷貝與淺拷貝，簡單點來說，就是假設B複製了A，當修改A時，看B是否會發生變化，如果B也跟著變了，說明這是淺拷貝，拿人手短，如果B沒變，那就是深拷貝，自食其力。此篇文章中也會簡單闡述到棧堆，基本資料型別與引用資料型別，因為這些概念能更好的讓你理解深拷貝與淺拷貝。我們來舉個淺拷貝例

[Python3 填坑] 009 深拷貝與淺拷貝

1. print( 坑的信息 )

2. 開始填坑

(1) 問題描述

(2) Python3.7.2 官方文檔

(3) 先說結論

1) 復合對象談深拷貝與淺拷貝的區別才有意義

2) 深拷貝常伴隨兩個問題，而淺拷貝對此無需擔心

3) deepcopy() 通過以下方式避免 2) 的問題：

4) 補充

(4) 少廢話，上例子

(5) 召喚深拷貝

(6) 關於不可變元素

相關推薦