얕은 복제본에서 딥코프 및 일반 지정 작업이 차이가 뭘까?

 
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

만약 내가 수행되는지 딥코프:

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

누군가 설명하란말야 정확히 무엇을 할 수 있는 차이점은 복제본에? 뭔가 &amp 관련된 것은 변경 가능. 불변 객체는? 그렇다면, 제발 설명하란말야 it to me?

Georgy
편집된 질문7일 10월 2019 в 9:28
프로그래밍
copy python variable-assignment immutability deep-copy
22일 6월 2013 в 2:15
21 파운드
해결책

이 작업은 단순히 기존 객체에는 향해 새로운 변수가 일반 할당에서는 점. 이 [docs] (http://docs.python.org/2/library/copy.html) 등을 제외한 깊이형 복제본에 사이의 차이를 설명한다.

&gt. 유일한 차이점은 관련이 깊고 얕은 복사 &gt. 오브젝트 (개체, 객체 또는 같은 다른 열거합니다 포함된 복합 &gt. 클래스 인스턴스): &gt. &gt. - 단순 복사본을 생성합니다 후 새로운 복합 객체 (가능한 범위까지) 에 있는 redhat. 삽입물의 참조입니다 객체에는 원본. &gt. &gt. - 새로운 복합 객체에는 깊은 복제본에 구문, it 에 발견된 후, 재귀적으로 삽입물의 복제본에 객체의 &gt. 원본.

39 의 here& 조금 데모:

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
grc
편집된 답변22일 6월 2013 в 2:45
해설 (10)

필요 없는 데이터 변경 불가 오브젝트에도 때문에 결코 바뀔 수 있기 때문에, Python 은 동일한 데이터 복사 id 는 항상 같은. 이후 그들은 잠재적으로는 바꼈소, [얕은] 복제본에 변경 가능 오브젝트에도 새 객체를 만듭니다.

복제본에 네스트된 구조를 깊은 관련이 있다. 또한 '의 경우' 복제본에 목록니다 관심용 열거합니다 딥코프 네스트된 열거합니다 있기 때문에, you have a new 외부 목록, 재귀 복제본입니다. 부트해 복제본에 열거합니다 하지만 내부 참조입니다.

이는 단순히 오래된 데이터를 할당에서는 언약보다는 복제본입니다. 참조입니다 설정합니다. 그래서 이 같은 내용의 새 목록 작성 사본이라는 함께 합니다.

Phillip
편집된 답변3일 2월 2017 в 11:03
해설 (2)

불변 객체를 생성할 수 있도록, t # 39 의 don& 복제본에 있기 훨씬 감지에서 바뀌지 않습니다. ['할당에서는'] (객체에는 변경 가능 https://docs.python.org/3/reference/simple_stmts.html # 할당에서는 명령문입니다.), ['복제본에'] (https://docs.python.org/3/library/copy.html # 코피스코프) 및 ['딥코프'] (https://docs.python.org/3/library/copy.html # 코피.딥코프) 가 다르기 때문이다. 이들 각각의 예제와 함께 이야기할 수 있습니다.

단순히 할당 작업을 color_name 소스 타겟으로의 에드그 참조.

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

이제 'i' 와 'j' 는 기술적으로 동일한 목록. 'I' 와 'j' %s/dbase/ext_table. 모두 동일한 메모리 주소. 그 갱신 중 하나에 모든 그들 중 다른 반영됩니다. 에드그:

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

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

반면 '와' 새 '는' 복제본에 딥코프 복제본에 변수다. 이제 원래 변수를 변경되는지 반영되지 않습니다 가변적입니다 복사본, 그 반대의 경우도 마찬가지입니다. 그러나 (얕은 복제본에) ',' 복제본에 don& # 39, t 는 네스트된 오브젝트에도 복제본에 아닌 그냥 복사됩니다 네스트된 객체에는 참조. 모든 네스트된 객체에는 딥코프 복제본에 재귀적으로.

비스무트-212 의 '복제본에 증명하기 위한 몇 가지 예를 들면' 와 '딥코프':

  • '*' 복제본에 사용 예를 평면 목록
>>> 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
  • '*' 복제본에 사용한 예를 네스트된 목록
>>> 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
  • 균등형 사용한 예를 딥코프 '*' 목록
>>> 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
  • 사용 예를 '' :* 딥코프 네스트된 목록
>>> 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
Sohaib Farooqi
편집된 답변24일 4월 2018 в 1:01
해설 (0)

39 에 표시되는 let& 어떻게 다음 코드가 실행될 수 있는 그래픽 예:

import copy

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

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

! [입력하십시오. 이미지 여기에 설명을] [1]

해설 (0)

a, b, c, d, a1, b1, c1 과 d1, 이는 해당 id 가 메모리에 대한 참조입니다 객체에는 식별됩니다.

지정 작업이 객체에 대한 참조가 color_name 메모리의 한 데 대한 참조입니다 있는 새로운 이름. 'c = [1.2,3.4]' 는 새로운 목록을 만드는 할당에서는 해당 객체를 포함하는 4 개의 정수, 그 객체에는 color_name 'c' 를 참조. c1 = c '는' 같은 동일한 개체 참조 및 color_name 할당에서는 처리하는 것이 'c1'. 이 목록은 해당 목록을 볼 수 있는 만큼 어떤 변화가 발생합니까 변경 가능 여부와 상관없이 액세스하면 c1 ',' c '또는' 이 모두 같은 개체 참조를 통해 있기 때문이다.

(c) '은' c1 = 코피스코프 &quot 얕은 copy"; 새로운 목록을 만드는 새로운 목록을 참조 및 color_name 'c1'. 'c' 여전히 원래 목록으로 가리킵니다. 따라서 목록에 있는 경우 ',' c '는' c1 dell. 나열하십시오 수정하십시오 변화가 없을 것입니다.

불변 객체는 정수 및 써줬지 같은 总监和首席信息官完全了解 복사는 관련이 없습니다. 이후 해당 객체를 수정할 필요가 전혀 없습니다. # 39, t 너회가 can& 복제본입니다 서로 다른 위치에 있는 두 개의 동일한 값을 메모리에. 그래서 정수 및 문장열 总监和首席信息官完全了解 복사 및 기타 일부 개체가 적용되지 않고, 단지 재할당됨. 이 때문에 'a' 와 'b' 동일한 결과 고객의 사례를 함께 받고 있다.

(c) '은' c1 = 코피.딥코프 깊이형 copy&quot "; 하지만 기능ᆞ기술과 얕은 복제본에 동일합니까 예제에서와. 깊이형 복제본에 얕은 복제본에 얕은 복제본에 다를 수 있는 새로운 객체 자체에 발쿰치로 복제본이므로 그 어떠한 참조입니다 δ1 해당 객체를 직접 않습니다 복사됩니다. 예를 들어, 내 목록에 정수만 그 안에 있다 (변경할 수 있는) 과 그 앞에서 살펴본 복사할 필요가 없습니다. 따라서 &quot deep"; 일부 깊이형 복제본에 적용되지 않습니다. 그러나 이러한 측면에서 볼 때 더 복잡한 목록:

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

이 목록은 다른 확장자입니다 열거합니다 (이차원 어레이입니다 이를 설명할 수도 있습니다).

실행하면 얕은 copy&quot "; 이를 "e1 '에' e ', 복사, 목록의 각 복제본이므로 변경되지만 너회가 발견하리니 해당 id 에 대한 참조를 사용하여 이 목록에 포함된 동일한 세 정수 몸에요 열거합니다 열거합니다 - 즉, 조교하실 할 경우 (3) ',' e '다음' e '약간만이라도 지아펜드 [0] [[1, 2, 3], [4, 5, 6], [7, 8, 9]]'. 그러나 또한 "e1 '수' [[1, 2, 3], [4, 5, 6], [7, 8, 9]] '. 반면, 나중에 에드라펜드 아니하였으매 ' ([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]]'. # 39 의 외부 that& 때문에 처음에 세 개가 3 각 객체는 참조 개별적입니다 열거합니다 내부 있습니다. 내부 열거합니다 변경 내용을 수정할 경우, 아무리 표시하는가에 하나의 복제본에 직접 볼 수 있는 경우 또는 다른. 하지만 위와 같이, 다음 중 하나를 수정하면 외부 열거합니다 'e' 를 원래 3 세 개의 참조입니다 구성형 열거합니다 하나 더 새로운 목록을 참조. E1 '와' 만 map_layer 여전히 원래의 삼 참조입니다.

39, & # 39 는 깊이형 copy&. 하지만 이 또한 복제본임을 죽이려하겠어요 아니라 외부 목록을 나열하고 복제본임을 도왔으매 열거합니다 들어가 안쪽 두 결과 객체를 같은 참조입니다 포함되지 않습니다 (mutable 객체에는 내린 것으로 우려하고 있다). 내부 열거합니다 인도하심이라만일 열거합니다 경우 더 이상 (또는 다른 객체에는 등 사전) 그들 내부에 너무 약간만이라도 중복됨. # 39, & # 39 의 that& deep& # 39;; # 39, & # 39, 깊이형 copy& 부분이다.

해설 (0)

목록에 있는 등, 파이썬, 우리가 일반적으로 사용하는 등 다른 딕트 할당할지 객체에는 튜플을 객체에는 & # 39. = & # 39. 예증으로, 파이썬 tcpg 복제본에 참조별로 의 . 즉, 우리는 다음과 같은 바뀌엇어요 합시다 목록

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

하나님은 이 목록에 할당할지 다음과 같은 다른 목록

list2 = list1

python 에서 list2 신앙이니라 저희에게는힘과 인쇄하십시오 털미널 우리는거야 afaq afnor:

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

모두 list1 &amp. 동일한 메모리 위치를 가리키는 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’

모두가 변경 및 list2 list1 받게 된다.

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

, 는 이제 완전히 격리됨 객체에는 서로 아웃해야 깊이형 복제본에 작성 중. 만약 두 개체를 통해 모두가 모피쳐 &amp 복사됩니다 깊이형 복제본에. 정보기술 (it) 의 하위 다른 메모리 위치를 가리키는 것입니다. 예:

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

희망을 줍니다.

해설 (0)

위에서 언급한 확신할 수 있지만 그렇지 않을 경우 it& # 39 의 원본 객체를 생성할 수 있는 매우 수입할 수 있는 알아 보았 참조 복사 (). 원본 객체를 변경하면 복사됨 객체에는 변경할 수 있습니다. 새 객체 및 높여줍니까 이딥코프 () 는 실제 원본 객체를 복사하는 새로운 하나. # 39, 원본 객체를 변경하면 doesn& 새로운 딥코필드 객체에는 영향을 주지 않는다.

원본 객체를 생성할 수 있으며, 복사 및 그러하너라 복제본에 이딥코프 () () 의 첫 번째 개체 참조를 반복적으로 데이터 원본 객체를.

따라서 복사 / 참조 복사 () 와 이딥코프 () 는 차이가 크다.

해설 (0)

아래 코드와 사용하는 방법을 사용하여, 얕은 복제본에 차이는 할당에서는 복제본에 얕은 복제본에 (슬라이스에) [.] 그리고 딥코프. 아래 예제는 네스트된 열거합니다 만들어 더 많은 차이를 볼 수 있습니다.

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]))
해설 (0)

로만스였나 취할 수 있도록 골자다. (아니, 그냥 단일 요소를 sub_lists) 를 다루는 얕은 열거합니다 &quot 일반 assignment"; 다 한 &quot 때는기대어 effect"; 얕은 목록을 만들 때 사용하는 이 목록을 만든 후 정상적인 assignment&quot 복제본에 ";). 이 &quot 때는기대어 effect"; 이 때문에 모든 요소에 목록을 다운로드합니까 변경할 때 자동으로 생성된 것으로, 원래 같은 요소를 변경하십시오 목록. 즉, 이는 '때' 복제본에 완료되니라 도움이 won& # 39, t change 변경할 때 원래 목록으로 요소를 복제본에 요소.

반면 '에서' 복제본에 투명지에 &quot 때는기대어 effect"; 물론 이 경우 '및' 딥코프 열거합니다 바뀌엇어요 항목이없습니다 (sub_lists) 를 통해 해결할 수 있습니다. 예를 들어 있는 큰 목록을 만들 경우 네스트된 열거합니다 만들 경우 복제본입니다 항목이없습니다 (sub_lists) 이 큰 목록 (원래 목록). 이 &quot 때는기대어 effect"; 이 때 자동으로 되는 목록을 다운로드합니까 sub_lists 수정하십시오 발생할 것이라고 sub_lists 수정하십시오 빅 목록. 가끔 (일부 프로젝트) 유지하려는 큰 수정 없이 그대로 목록 (원래 목록에), 모든 운영까지도 사본을 만드는 요소 (sub_lists) 가 있다. 이를 위해 가장 적합한 솔루션을 사용할 수 있는 '는' 이 &quot 딥코프 잘있게나 때는기대어 effect"; 원래 내용 수정 없이 복제본에 만들어 집니다.

다른 비헤이비어를 '만' 와 '의' 복제본에 깊이형 복제본에 운영과 관련된 사항이 복합 객체 (예: 같은 다른 객체를 포함하는 객체에는 열거합니다).

다음은 이 차이를 설명한 간단한 코드 예제:

  • 최초로 *

39 의 검사, 어떻게 ',' (얕은) 가 let& 복제본에 original 목록과 사본을 만들어 이 목록:

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

이제 let& # 39 의 일부 '테스트' 어때, 원래 목록으로 비해 실행하십시오 인쇄하십시오 목록을 다운로드합니까 역할이 있다.

각기 다른 주소 및 copy_list original_list

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

요소 및 copy_list 충족합니다 original_list 같습니다.

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

의 original_list 및 copy_list 충족합니다 sub_elements 같습니다.

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]

자동으로 sub_elements copy_list 수정하십시오 sub_elements original_list 수정

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]

자동으로 sub_elements original_list 수정하십시오 sub_elements copy_list 수정

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]
  • 보조 *

39 의 검사, ',' 가 어떻게 let& 딥코프 수행여 같은 일이 아니라 우리가 함께 한 '복제본에' (original 목록과 사본을 만드는 이 목록):

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

이제 let& # 39 의 일부 '테스트' 어때, 원래 목록으로 비해 실행하십시오 인쇄하십시오 목록을 다운로드합니까 역할이 있다.

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

각기 다른 주소 및 copy_list original_list

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

요소 및 copy_list 충족합니다 original_list 같습니다.

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

sub_elements copy_list 충족합니다 original_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]
Fouad Boukredine
편집된 답변24일 4월 2018 в 12:41
해설 (0)
>>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.
Georgy
편집된 답변7일 10월 2019 в 9:37
해설 (1)