ความแตกต่างระหว่างการคัดลอกตื้นลึกและการดำเนินการมอบหมายปกติคืออะไร?

import copy

a = "deepak"
b = 1, 2, 3, 4
c = [1, 2, 3, 4]
d = {1: 10, 2: 20, 3: 30}

a1 = copy.copy(a)
b1 = copy.copy(b)
c1 = copy.copy(c)
d1 = copy.copy(d)


print("immutable - id(a)==id(a1)", id(a) == id(a1))
print("immutable - id(b)==id(b1)", id(b) == id(b1))
print("mutable - id(c)==id(c1)", id(c) == id(c1))
print("mutable - id(d)==id(d1)", id(d) == id(d1))

ฉันได้รับผลลัพธ์ต่อไปนี้:

immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False

ถ้าฉันเล่น deepcopy:

a1 = copy.deepcopy(a)
b1 = copy.deepcopy(b)
c1 = copy.deepcopy(c)
d1 = copy.deepcopy(d)

ผลลัพธ์เหมือนกัน:

immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False

ถ้าฉันทำงานเกี่ยวกับการมอบหมาย:

a1 = a
b1 = b
c1 = c
d1 = d

ผลลัพธ์คือ:

immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) True
mutable - id(d)==id(d1) True

ใครสามารถอธิบายสิ่งที่สร้างความแตกต่างระหว่างสำเนาได้อย่างแน่นอน? มันเกี่ยวข้องกับวัตถุที่ไม่แน่นอนและไม่แน่นอนหรือไม่? ถ้าเป็นเช่นนั้นคุณช่วยอธิบายให้ฉันฟังหน่อยได้ไหม?

การดำเนินการกำหนดปกติเพียงแค่ชี้ตัวแปรใหม่ไปยังวัตถุที่มีอยู่ เอกสารอธิบายความแตกต่างระหว่างตื้นและสำเนาลึก:

ความแตกต่างระหว่างการทำสำเนาแบบตื้นและลึกนั้นเกี่ยวข้องเฉพาะกับวัตถุแบบผสม (วัตถุที่มีวัตถุอื่น ๆ เช่นรายการหรืออินสแตนซ์ของคลาส):

• สำเนาตื้นสร้างวัตถุประกอบใหม่แล้ว (เท่าที่เป็นไปได้) แทรกการอ้างอิงลงในวัตถุที่พบในต้นฉบับ

• การทำสำเนาแบบลึกจะสร้างวัตถุผสมใหม่จากนั้นแทรกการทำสำเนาซ้ำลงในวัตถุที่พบในต้นฉบับ

นี่เป็นการสาธิตเล็กน้อย:

import copy

a = [1, 2, 3]
b = [4, 5, 6]
c = [a, b]

การใช้งานปกติที่ได้รับมอบหมายเพื่อคัดลอก:

d = c

print id(c) == id(d)          # True - d is the same object as c
print id(c[0]) == id(d[0])    # True - d[0] is the same object as c[0]

ใช้สำเนาตื้น:

d = copy.copy(c)

print id(c) == id(d)          # False - d is now a new object
print id(c[0]) == id(d[0])    # True - d[0] is the same object as c[0]

ใช้สำเนาลึก:

d = copy.deepcopy(c)

print id(c) == id(d)          # False - d is now a new object
print id(c[0]) == id(d[0])    # False - d[0] is now a new object

สำหรับวัตถุที่ไม่เปลี่ยนรูปไม่จำเป็นต้องคัดลอกเพราะข้อมูลจะไม่เปลี่ยนแปลงดังนั้น Python จึงใช้ข้อมูลเดียวกัน รหัสจะเหมือนกันเสมอ สำหรับวัตถุที่ไม่แน่นอนเนื่องจากพวกเขาสามารถเปลี่ยนแปลงสำเนาตื้น [สร้าง] วัตถุใหม่

สำเนาลึกเกี่ยวข้องกับโครงสร้างที่ซ้อนกัน หากคุณมีรายการของรายการcopiesให้คัดลอกรายชื่อซ้อนซ้ำดังนั้นมันจึงเป็นสำเนาซ้ำ เพียงแค่คัดลอกคุณจะมีรายการนอกใหม่ แต่รายการภายในเป็นการอ้างอิง

การมอบหมายไม่ได้คัดลอก มันเพียงแค่ตั้งค่าการอ้างอิงไปยังข้อมูลเก่า ดังนั้นคุณต้องคัดลอกเพื่อสร้างรายการใหม่ที่มีเนื้อหาเดียวกัน

สำหรับวัตถุที่ไม่เปลี่ยนรูปการสร้างสำเนาไม่สมเหตุสมผลเนื่องจากไม่มีการเปลี่ยนแปลง สำหรับวัตถุที่ไม่แน่นอนassignment, copyและdeepcopyทำงานแตกต่างกัน ให้พูดถึงแต่ละตัวอย่างด้วย

การดำเนินการมอบหมายเพียงมอบหมายการอ้างอิงของแหล่งที่มาไปยังปลายทางเช่น:

>>> i = [1,2,3]
>>> j=i
>>> hex(id(i)), hex(id(j))
>>> ('0x10296f908', '0x10296f908') #Both addresses are identical

ตอนนี้iและjทางเทคนิคหมายถึงรายการเดียวกัน ทั้งสองiและjมีที่อยู่หน่วยความจำเดียวกัน การอัปเดตใด ๆ ของทั้งคู่จะส่งผลต่อกัน เช่น:

>>> i.append(4)
>>> j
>>> [1,2,3,4] #Destination is updated

>>> j.append(5)
>>> i
>>> [1,2,3,4,5] #Source is updated

ในทางตรงกันข้ามcopyและdeepcopyสร้างสำเนาของตัวแปรใหม่ ดังนั้นตอนนี้การเปลี่ยนแปลงตัวแปรดั้งเดิมจะไม่สะท้อนให้เห็นถึงตัวแปรการคัดลอกและในทางกลับกัน อย่างไรก็ตามcopy(shallow copy)อย่าสร้างสำเนาของวัตถุที่ซ้อนกัน แต่เพียงแค่คัดลอกข้อมูลอ้างอิงของวัตถุที่ซ้อนอยู่ Deepcopy คัดลอกวัตถุซ้อนกันทั้งหมดซ้ำ

ตัวอย่างบางส่วนที่แสดงให้เห็นถึงพฤติกรรมของcopyและdeepcopy:

ตัวอย่างรายการแบบเรียบโดยใช้copy:

>>> import copy
>>> i = [1,2,3]
>>> j = copy.copy(i)
>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different

>>> i.append(4)
>>> j
>>> [1,2,3] #Updation of original list didn't affected copied variable

ตัวอย่างรายการแบบซ้อนโดยใช้copy:

>>> import copy
>>> i = [1,2,3,[4,5]]
>>> j = copy.copy(i)

>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different

>>> hex(id(i[3])), hex(id(j[3]))
>>> ('0x10296f908', '0x10296f908') #Nested lists have same address

>>> i[3].append(6)
>>> j
>>> [1,2,3,[4,5,6]] #Updation of original nested list updated the copy as well

ตัวอย่างรายการแบบเรียบโดยใช้deepcopy:

>>> import copy
>>> i = [1,2,3]
>>> j = copy.deepcopy(i)
>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different

>>> i.append(4)
>>> j
>>> [1,2,3] #Updation of original list didn't affected copied variable

ตัวอย่างรายการแบบซ้อนโดยใช้deepcopy:

>>> import copy
>>> i = [1,2,3,[4,5]]
>>> j = copy.deepcopy(i)

>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different

>>> hex(id(i[3])), hex(id(j[3]))
>>> ('0x10296f908', '0x102b9b7c8') #Nested lists have different addresses

>>> i[3].append(6)
>>> j
>>> [1,2,3,[4,5]] #Updation of original nested list didn't affected the copied variable    

เรามาดูตัวอย่างกราฟิกในการรันโค้ดต่อไปนี้

import copy

class Foo(object):
    def __init__(self):
        pass


a = [Foo(), Foo()]
shallow = copy.copy(a)
deep = copy.deepcopy(a)

a, b, c, d, a1, b1, c1 และ d1 เป็นการอ้างถึงออบเจ็กต์ในหน่วยความจำซึ่งมีการระบุเอกลักษณ์โดยรหัสของพวกเขา

การดำเนินการที่ได้รับมอบหมายจะอ้างอิงไปยังวัตถุในหน่วยความจำและมอบหมายการอ้างอิงนั้นให้กับชื่อใหม่ c=[1,2,3,4]เป็นการกำหนดที่สร้างวัตถุรายการใหม่ที่มีจำนวนเต็มสี่จำนวนและกำหนดการอ้างอิงไปยังวัตถุนั้นcนั้น c1=cเป็นงานที่ต้องใช้การอ้างอิงเดียวกันกับวัตถุเดียวกันc1และกำหนดว่า เนื่องจากรายการไม่สามารถเปลี่ยนแปลงได้สิ่งใดก็ตามที่เกิดขึ้นกับรายการนั้นจะสามารถมองเห็นได้ไม่ว่าคุณจะเข้าถึงรายการนั้นcหรือc1เพราะทั้งคู่อ้างถึงวัตถุเดียวกัน

c1=copy.copy(c)เป็น "คัดลอกตื้น" c1ที่สร้างรายการใหม่และกำหนดอ้างอิงถึงรายการใหม่ที่จะ cยังคงชี้ไปที่รายการเดิม ดังนั้นหากคุณแก้ไขรายการที่c1รายการที่cอ้างถึงจะไม่เปลี่ยนแปลง

แนวคิดของการคัดลอกไม่เกี่ยวข้องกับวัตถุที่ไม่เปลี่ยนรูปเช่นจำนวนเต็มและสตริง เนื่องจากคุณไม่สามารถแก้ไขวัตถุเหล่านั้นได้จึงไม่จำเป็นต้องมีสำเนาสองค่าที่เหมือนกันในหน่วยความจำในสถานที่ต่างกัน ดังนั้นจำนวนเต็มและสตริงและวัตถุอื่น ๆ ที่แนวคิดของการคัดลอกใช้ไม่ได้ถูกกำหนดใหม่ นี่คือเหตุผลที่ตัวอย่างของคุณมีaและbส่งผลให้รหัสที่เหมือนกัน

c1=copy.deepcopy(c)เป็น "สำเนาลึก" แต่ฟังก์ชั่นจะเหมือนกับสำเนาตื้นในตัวอย่างนี้ สำเนาลึก ๆ นั้นแตกต่างจากสำเนาตื้น ๆ ในสำเนาตื้น ๆ นั้นจะทำสำเนาของวัตถุใหม่ แต่มีการอ้างอิงภายในวัตถุนั้นจะไม่ถูกคัดลอก ในตัวอย่างของคุณรายการของคุณมีจำนวนเต็มเท่านั้น (ซึ่งไม่เปลี่ยนรูป) และตามที่กล่าวไว้ก่อนหน้านี้ไม่จำเป็นต้องคัดลอกรายการเหล่านั้น ดังนั้นส่วน "ลึก" ของสำเนาลึกจึงไม่มีผล อย่างไรก็ตามพิจารณารายการที่ซับซ้อนมากขึ้น:

e = [[1, 2],[4, 5, 6],[7, 8, 9]]

นี่คือรายการที่มีรายการอื่น ๆ (คุณสามารถอธิบายเป็นอาร์เรย์สองมิติได้)

หากคุณเปิด "คัดลอกตื้น" บนeคัดลอกไปที่e1คุณจะพบว่า id ของรายการเปลี่ยนแปลง แต่สำเนาแต่ละรายการมีการอ้างอิงไปยังสามรายการเดียวกัน - รายการที่มีจำนวนเต็มภายใน นั่นหมายความว่าถ้าคุณต้องทำe[0].append(3)มันก็eจะเป็น[[1, 2, 3],[4, 5, 6],[7, 8, 9]]เช่นนั้น แต่ยังจะเป็นe1 [[1, 2, 3],[4, 5, 6],[7, 8, 9]]ในทางตรงกันข้ามถ้าคุณต่อมาได้e.append([10, 11, 12]), eจะ[[1, 2, 3],[4, 5, 6],[7, 8, 9],[10, 11, 12]]จะเป็นแต่จะยังคงเป็นe1 [[1, 2, 3],[4, 5, 6],[7, 8, 9]]นั่นเป็นเพราะรายการด้านนอกเป็นวัตถุที่แยกกันในตอนแรกแต่ละรายการมีการอ้างอิงสามรายการไปยังรายการภายในสามรายการ หากคุณแก้ไขรายการภายในคุณสามารถดูการเปลี่ยนแปลงเหล่านั้นได้ไม่ว่าคุณจะดูผ่านหนึ่งสำเนาหรืออย่างอื่น แต่ถ้าคุณปรับเปลี่ยนหนึ่งในรายการภายนอกดังกล่าวข้างต้นแล้วeมีการอ้างอิงสามรายการไปยังสามรายการดั้งเดิมบวกอีกหนึ่งการอ้างอิงไปยังรายการใหม่ และe1ยังคงมีเพียงสามการอ้างอิงเดิม

'สำเนาลึก' จะไม่เพียง แต่ทำซ้ำรายการด้านนอก แต่มันจะเข้าไปในรายการและทำซ้ำรายการภายในเพื่อให้วัตถุสองรายการที่เกิดขึ้นไม่ได้มีการอ้างอิงเดียวกันใด ๆ (เท่าที่เกี่ยวข้องกับวัตถุที่ไม่แน่นอน) . หากรายการภายในมีรายการเพิ่มเติม (หรือวัตถุอื่น ๆ เช่นพจนานุกรม) ภายในรายการเหล่านั้นก็จะถูกทำซ้ำเช่นกัน นั่นคือส่วน 'ลึก' ของ 'สำเนาลึก'

ในหลามเมื่อเรากำหนดวัตถุเช่นรายการ tuples, Dict, ฯลฯ เพื่อวัตถุอื่นมักจะมี '=' สัญญาณหลามสร้างสำเนาของการอ้างอิง นั่นคือสมมติว่าเรามีรายการเช่นนี้:

list1 = [ [ 'a' , 'b' , 'c' ] , [ 'd' , 'e' , 'f' ]  ]

และเรากำหนดรายการอื่นให้กับรายการนี้เช่น:

list2 = list1

ถ้าเราพิมพ์ list2 ใน terminal ของไพ ธ อนเราจะได้สิ่งนี้:

list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]

ทั้ง list1 & list2 กำลังชี้ไปยังตำแหน่งหน่วยความจำเดียวกันการเปลี่ยนแปลงใด ๆ กับสิ่งใดก็ตามจะส่งผลให้เกิดการเปลี่ยนแปลงที่มองเห็นได้ในวัตถุทั้งสองเช่นวัตถุทั้งสองชี้ไปยังตำแหน่งหน่วยความจำเดียวกัน ถ้าเราเปลี่ยน list1 ดังนี้:

list1[0][0] = 'x’
list1.append( [ 'g'] )

ดังนั้นทั้ง list1 และ list2 จะเป็น:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g'] ]
list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g’ ] ]

ตอนนี้มาถึงการคัดลอกตื้นเมื่อวัตถุสองชิ้นถูกคัดลอกผ่านสำเนาตื้นวัตถุลูกของวัตถุแม่ทั้งสองอ้างถึงตำแหน่งหน่วยความจำเดียวกัน แต่การเปลี่ยนแปลงใหม่เพิ่มเติมในวัตถุคัดลอกใด ๆ จะเป็นอิสระต่อกัน ลองมาทำความเข้าใจกับตัวอย่างเล็ก ๆ สมมติว่าเรามีข้อมูลโค้ดขนาดเล็กนี้:

import copy

list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]      # assigning a list
list2 = copy.copy(list1)       # shallow copy is done using copy function of copy module

list1.append ( [ 'g', 'h', 'i'] )   # appending another list to list1

print list1
list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ]
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

แจ้งให้ทราบล่วงหน้า list2 ยังคงไม่ได้รับผลกระทบ แต่ถ้าเราทำการเปลี่ยนแปลงวัตถุย่อยเช่น:

list1[0][0] = 'x’

ดังนั้นทั้ง list1 และ list2 จะได้รับการเปลี่ยนแปลง:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] 
list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] ]

ตอนนี้การทำสำเนาแบบลึกจะช่วยในการสร้างวัตถุที่แยกออกจากกันอย่างสมบูรณ์ หากมีการคัดลอกวัตถุสองรายการผ่านการคัดลอกลึกผู้ปกครองทั้งสองคน & ของเด็กจะชี้ไปยังตำแหน่งหน่วยความจำที่แตกต่าง ตัวอย่าง:

import copy

list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ']  ]         # assigning a list
list2 = deepcopy.copy(list1)       # deep copy is done using deepcopy function of copy module

list1.append ( [ 'g', 'h', 'i'] )   # appending another list to list1

print list1
list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ]
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

แจ้งให้ทราบล่วงหน้า list2 ยังคงไม่ได้รับผลกระทบ แต่ถ้าเราทำการเปลี่ยนแปลงวัตถุย่อยเช่น:

list1[0][0] = 'x’

จากนั้น list2 จะไม่ได้รับผลกระทบเนื่องจากวัตถุลูกทั้งหมดและวัตถุแม่ชี้ไปยังตำแหน่งหน่วยความจำที่แตกต่างกัน:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] 
list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f  ' ] ]

หวังว่ามันจะช่วย

รหัสด้านล่างแสดงให้เห็นถึงความแตกต่างระหว่างการมอบหมายการคัดลอกตื้นโดยใช้วิธีการคัดลอกการคัดลอกตื้นโดยใช้ (ชิ้น) [:] และการพิมพ์ลึก ตัวอย่างด้านล่างใช้รายการซ้อนกันที่นั่นโดยสร้างความแตกต่างให้ชัดเจนยิ่งขึ้น

from copy import deepcopy

########"List assignment (does not create a copy) ############
l1 = [1,2,3, [4,5,6], [7,8,9]]
l1_assigned = l1

print(l1)
print(l1_assigned)

print(id(l1), id(l1_assigned))
print(id(l1[3]), id(l1_assigned[3]))
print(id(l1[3][0]), id(l1_assigned[3][0]))

l1[3][0] = 100
l1.pop(4)
l1.remove(1)


print(l1)
print(l1_assigned)
print("###################################")

########"List copy using copy method (shallow copy)############

l2 = [1,2,3, [4,5,6], [7,8,9]]
l2_copy = l2.copy()

print(l2)
print(l2_copy)

print(id(l2), id(l2_copy))
print(id(l2[3]), id(l2_copy[3]))
print(id(l2[3][0]), id(l2_copy[3][0]))
l2[3][0] = 100
l2.pop(4)
l2.remove(1)


print(l2)
print(l2_copy)

print("###################################")

########"List copy using slice (shallow copy)############

l3 = [1,2,3, [4,5,6], [7,8,9]]
l3_slice = l3[:]

print(l3)
print(l3_slice)

print(id(l3), id(l3_slice))
print(id(l3[3]), id(l3_slice[3]))
print(id(l3[3][0]), id(l3_slice[3][0]))

l3[3][0] = 100
l3.pop(4)
l3.remove(1)


print(l3)
print(l3_slice)

print("###################################")

########"List copy using deepcopy ############

l4 = [1,2,3, [4,5,6], [7,8,9]]
l4_deep = deepcopy(l4)

print(l4)
print(l4_deep)

print(id(l4), id(l4_deep))
print(id(l4[3]), id(l4_deep[3]))
print(id(l4[3][0]), id(l4_deep[3][0]))

l4[3][0] = 100
l4.pop(4)
l4.remove(1)

print(l4)
print(l4_deep)
print("##########################")
print(l4[2], id(l4[2]))
print(l4_deep[3], id(l4_deep[3]))

print(l4[2][0], id(l4[2][0]))
print(l4_deep[3][0], id(l4_deep[3][0]))

รายการที่ต้องดำเนินการคือ: การจัดการกับรายการที่ตื้น (ไม่มี sub_lists เพียงองค์ประกอบเดียว) โดยใช้ "การมอบหมายปกติ" เพิ่ม "ผลข้างเคียง" เมื่อคุณสร้างรายการที่ตื้นแล้วคุณสร้างสำเนาของรายการนี้โดยใช้ "การมอบหมายปกติ" . "ผลข้างเคียง" นี้คือเมื่อคุณเปลี่ยนองค์ประกอบใด ๆ ของรายการคัดลอกที่สร้างขึ้นเพราะมันจะเปลี่ยนองค์ประกอบเดียวกันของรายการต้นฉบับโดยอัตโนมัติ นั่นคือเมื่อcopyมีประโยชน์เพราะจะไม่เปลี่ยนองค์ประกอบรายการดั้งเดิมเมื่อเปลี่ยนองค์ประกอบการคัดลอก

ในทางกลับกันcopyจะมี "ผลข้างเคียง" เช่นกันเมื่อคุณมีรายการที่มีรายการอยู่ในนั้น (sub_lists) และdeepcopyแก้ไขได้ ตัวอย่างเช่นถ้าคุณสร้างรายการใหญ่ที่มีรายการซ้อนอยู่ในนั้น (sub_lists) และคุณสร้างสำเนาของรายการใหญ่นี้ (รายการเดิม) "ผลข้างเคียง" จะเกิดขึ้นเมื่อคุณแก้ไขรายการย่อยของรายการคัดลอกซึ่งจะแก้ไขรายการย่อยของรายการใหญ่โดยอัตโนมัติ บางครั้ง (ในบางโครงการ) คุณต้องการเก็บรายการขนาดใหญ่ (รายการดั้งเดิมของคุณ) ตามที่ไม่มีการแก้ไขและสิ่งที่คุณต้องการคือการทำสำเนาองค์ประกอบ (sub_lists) สำหรับวิธีการแก้ปัญหาของคุณคือการใช้deepcopyซึ่งจะดูแล "ผลข้างเคียง" นี้และทำสำเนาโดยไม่ต้องแก้ไขเนื้อหาต้นฉบับ

พฤติกรรมที่แตกต่างกันของcopyและdeep copyการดำเนินงานที่เกี่ยวข้องกับวัตถุผสมเท่านั้น (เช่น: วัตถุที่มีวัตถุอื่น ๆ เช่นรายการ)

นี่คือความแตกต่างที่แสดงในตัวอย่างรหัสง่ายๆนี้:

เป็นครั้งแรก

มาตรวจสอบcopyพฤติกรรม (ตื้น) โดยการสร้างรายการต้นฉบับและสำเนาของรายการนี้:

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.copy(original_list)

ตอนนี้เรามาทำการprintทดสอบกันแล้วดูว่ารายการต้นฉบับมีคุณสมบัติอย่างไรเมื่อเทียบกับรายการคัดลอก:

original_list และ copy_list มีที่อยู่ต่างกัน

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

องค์ประกอบของ original_list และ copy_list มีที่อยู่เดียวกัน

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

sub_elements ของ original_list และ copy_list มีที่อยู่เดียวกัน

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x1faef08 0x1faef08

การปรับเปลี่ยนองค์ประกอบ original_list ไม่ได้แก้ไของค์ประกอบ copy_list

original_list.append(6)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

การแก้ไของค์ประกอบ copy_list ไม่ได้แก้ไของค์ประกอบ original_list

copy_list.append(7)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

การแก้ไข original_list sub_elements แก้ไขโดยอัตโนมัติ copy_list sub_elements

original_list[5].append('c')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 7]

การแก้ไข copy_list sub_elements โดยอัตโนมัติแก้ไข original_list sub_elements

copy_list[5].append('d')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 7]

ที่สอง

มาตรวจสอบdeepcopyพฤติกรรมโดยทำในสิ่งเดียวกันกับที่เราทำcopy(สร้างรายการต้นฉบับและสำเนาของรายการนี้):

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.copy(original_list)

ตอนนี้เรามาทำการprintทดสอบกันแล้วดูว่ารายการต้นฉบับมีคุณสมบัติอย่างไรเมื่อเทียบกับรายการคัดลอก:

import copy
original_list = [1, 2, 3, 4, 5, ['a', 'b']]
copy_list = copy.deepcopy(original_list)

original_list และ copy_list มีที่อยู่ต่างกัน

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

องค์ประกอบของ original_list และ copy_list มีที่อยู่เดียวกัน

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

sub_elements ของ original_list และ copy_list มีที่อยู่ต่างกัน

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x24eef08 0x24f3300

การปรับเปลี่ยนองค์ประกอบ original_list ไม่ได้แก้ไของค์ประกอบ copy_list

original_list.append(6)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

การแก้ไของค์ประกอบ copy_list ไม่ได้แก้ไของค์ประกอบ original_list

copy_list.append(7)
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

การแก้ไข original_list sub_elements ไม่ได้แก้ไข copy_list sub_elements

original_list[5].append('c')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

การแก้ไข copy_list sub_elements ไม่ได้แก้ไข original_list sub_elements

copy_list[5].append('d')
print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6]
print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'd'], 7]

ไม่แน่ใจว่ามันกล่าวถึงข้างต้นหรือไม่ แต่สามารถนำเข้าได้มากเพื่อยกเลิกการคัดลอก. คัดลอก () สร้างการอ้างอิงถึงวัตถุต้นฉบับ หากคุณเปลี่ยนวัตถุที่คัดลอก - คุณเปลี่ยนวัตถุเดิม .deepcopy () สร้างวัตถุใหม่และคัดลอกวัตถุต้นฉบับไปยังวัตถุใหม่จริง การเปลี่ยนวัตถุ Deepcopied ใหม่ไม่ส่งผลกระทบต่อวัตถุต้นฉบับ

และใช่ .deepcopy () คัดลอกวัตถุต้นฉบับซ้ำในขณะที่. คัดลอก () สร้างวัตถุอ้างอิงไปยังข้อมูลระดับแรกของวัตถุต้นฉบับ

ดังนั้นการคัดลอก / อ้างอิงความแตกต่างระหว่าง. คัดลอก () และ .deepcopy () จึงมีความสำคัญ

สำเนาลึกเกี่ยวข้องกับโครงสร้างที่ซ้อนกัน หากคุณมีรายการของรายการ Deepcopy ก็จะคัดลอกรายการที่ซ้อนกันด้วยดังนั้นจึงเป็นสำเนาที่เรียกซ้ำได้ เพียงแค่คัดลอกคุณจะมีรายการนอกใหม่ แต่รายการภายในเป็นการอ้างอิง การมอบหมายไม่ได้คัดลอก สำหรับอดีต

import copy
spam = [[0, 1, 2, 3], 4, 5]
cheese = copy.copy(spam)
cheese.append(3)
cheese[0].append(3)
print(spam)
print(cheese)

เอาท์พุต

[[0, 1, 2, 3, 3], 4, 5] [[0, 1, 2, 3, 3], 4, 5, 3] วิธีคัดลอกคัดลอกเนื้อหาของรายการนอกไปยังรายการใหม่ แต่รายการภายในคือ ยังคงเหมือนเดิมสำหรับทั้งสองรายการดังนั้นหากคุณทำการเปลี่ยนแปลงในรายการภายในของรายการใด ๆ รายการนั้นจะมีผลกับทั้งสองรายการ

แต่ถ้าคุณใช้ Deep copy แล้วมันจะสร้างอินสแตนซ์ใหม่สำหรับรายการภายในด้วย

import copy
spam = [[0, 1, 2, 3], 4, 5]
cheese = copy.deepcopy(spam)
cheese.append(3)
cheese[0].append(3)
print(spam)
print(cheese)

เอาท์พุต

[0, 1, 2, 3] [[0, 1, 2, 3, 3], 4, 5, 3]

>>lst=[1,2,3,4,5]

>>a=lst

>>b=lst[:]

>>> b
[1, 2, 3, 4, 5]

>>> a
[1, 2, 3, 4, 5]

>>> lst is b
False

>>> lst is a
True

>>> id(lst)
46263192

>>> id(a)
46263192 ------>  See here id of a and id of lst is same so its called deep copy and even boolean answer is true

>>> id(b)
46263512 ------>  See here id of b and id of lst is not same so its called shallow copy and even boolean answer is false although output looks same.