シャローコピー、ディープコピー、通常の割り当て操作の違いは何ですか?


210
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

誰かがコピー間で正確に違いをもたらすものを説明できますか?それは可変で不変のオブジェクトに関連したものですか?もしそうなら、それを私に説明してもらえますか?

回答:


364

通常の割り当て操作は、新しい変数を既存のオブジェクトに向けるだけです。ドキュメントは浅いと深いコピーの違いを説明します。

シャローコピーとディープコピーの違いは、複合オブジェクト(リストやクラスインスタンスなどの他のオブジェクトを含むオブジェクト)にのみ関係します。

  • 浅いコピーは、新しい複合オブジェクトを作成し、(可能な範囲で)元のオブジェクトにあるオブジェクトへの参照を挿入します。

  • ディープコピーは、新しい複合オブジェクトを構築し、再帰的に、元のオブジェクトにあるオブジェクトのコピーをそれに挿入します。

ここに小さなデモがあります:

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

5
暗殺は浅いコピーと同じですか?
deeshank 2013年

35
@Dshankいいえ。浅いコピーは新しいオブジェクトを作成しますが、割り当ては新しい変数を既存のオブジェクトにポイントするだけです。既存のオブジェクトを変更すると、両方の変数に影響します(割り当てあり)。
grc 2013年

13
@grc「既存のオブジェクトに変更を加えると、両方の変数に影響があります(割り当てあり)」-このステートメントは、可変オブジェクトにのみ当てはまり、文字列、浮動小数点、タプルなどの不変タイプには当てはまりません。
Neerav、2014年

1
@grcしかし、私は(私はここに新しい行を削除します。)の例を試してみましたが、まだ表示を。しかし、変更可能なリストです。list_=[[1,2],[3,4]] newlist = list_.copy() list_[0]=[7,8] print(list_) print(newlist)newlist[[1, 2], [3, 4]]list_[0]
Alston、2016年

1
@Stallman list_[0]は変更可能ですが、変更/修正していません。list_[0].append(9)またはlist_[0][0] = 7代わりに試してください。
grc 2016年

46

不変オブジェクトの場合、データが変更されることはないため、コピーする必要はありません。したがって、Pythonは同じデータを使用します。IDは常に同じです。可変オブジェクトの場合、変更される可能性があるため、[浅い]コピーは新しいオブジェクトを作成します。

ディープコピーはネストされた構造に関連しています。リストのリストがある場合はcopies、ネストされたリストもディープコピーするため、再帰的なコピーになります。コピーするだけで、新しい外部リストが作成されますが、内部リストは参照です。

割り当てはコピーされません。参照を古いデータに設定するだけです。そのため、同じ内容の新しいリストを作成するには、コピーが必要です。


With just copy, you have a new outer list but inner lists are references.内部リストの場合、コピーされたリストは元のリストの影響を受けますか?のようなリストのリストを作成しますがlist_=[[1,2],[3,4]] newlist = list_.copy() list_[0]=[7,8]newlist残りは同じなので、内部リストは参照ですか?
Alston、2016年

1
@Stallmanここで参照リストを変更するのではなく、新しいリストを作成して、それをコピーの1つの最初のアイテムとして割り当てます。やってみようlist_[0][0] = 7
perreal

20

不変オブジェクトの場合、変更を行わないため、コピーを作成してもあまり意味がありません。可変オブジェクトのassignment場合copydeepcopy動作が異なります。それぞれについて例を挙げて説明します。

割り当て操作は、ソースの参照を宛先に割り当てるだけです。例:

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

現在ij技術的には同じリストを参照しています。両方ij同じメモリアドレスを持っています。それらのいずれかへの更新は、他にも反映されます。例えば:

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

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

一方copydeepcopy変数の新しいコピーを作成します。したがって、元の変数への変更はコピー変数に反映されず、その逆も同様です。ただし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    

18

以下のコードがどのように実行されるかをグラフィカルな例で見てみましょう:

import copy

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


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

ここに画像の説明を入力してください


5

a、b、c、d、a1、b1、c1、d1は、メモリ内のオブジェクトへの参照であり、IDによって一意に識別されます。

割り当て操作は、メモリ内のオブジェクトへの参照を取得し、その参照を新しい名前に割り当てます。 c=[1,2,3,4]これらの4つの整数を含む新しいリストオブジェクトを作成し、そのオブジェクトへの参照をに割り当てる割り当てcです。 同じオブジェクトへの同じ参照をc1=c受け取りそれをに割り当てる割り当てですc1。リストは変更可能であるため、cまたはを介してアクセスするかどうかに関係なく、そのリストに発生するすべての内容は、どちらもc1同じオブジェクトを参照するため、表示されます。

c1=copy.copy(c)新しいリストを作成し、新しいリストへの参照をに割り当てる「浅いコピー」ですc1cまだ元のリストを指しています。したがって、でリストを変更してc1も、c参照するリストは変更されません。

コピーの概念は、整数や文字列などの不変オブジェクトには関係ありません。これらのオブジェクトは変更できないため、メモリ内の異なる場所に同じ値の2つのコピーを置く必要はありません。したがって、整数と文字列、およびコピーの概念が適用されない他のいくつかのオブジェクトは、単に再割り当てされます。これは、なぜあなたの例であるab、同一のIDで結果。

c1=copy.deepcopy(c)「ディープコピー」ですが、この例のシャローコピーと同じように機能します。深いコピーは浅いコピーとは異なり、浅いコピーはオブジェクト自体の新しいコピーを作成しますが、そのオブジェクト内の参照はそれ自体はコピーされません。あなたの例では、リストには整数(不変)のみが含まれており、前述のとおり、それらをコピーする必要はありません。したがって、ディープコピーの「ディープ」部分は適用されません。ただし、次のより複雑なリストを検討してください。

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

これは、他のリストを含むリストです(2次元配列として説明することもできます)。

で「浅いコピー」を実行してeにコピーするとe1、リストのIDが変更されますが、リストの各コピーには、同じ3つのリストへの参照(内部に整数を含むリスト)が含まれています。つまり、もしそうしたなら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]]。これは、外部リストが個別のオブジェクトであり、最初はそれぞれ3つの内部リストへの3つの参照が含まれているためです。内部リストを変更すると、どちらのコピーから表示しても、それらの変更を確認できます。しかし、上記のように外部リストの1つを変更すると、e元の3つのリストへの3つの参照と、新しいリストへのもう1つの参照が含まれています。またe1、元の3つの参照のみが含まれています。

「ディープコピー」は、外側のリストを複製するだけでなく、リストの内側に移動して内側のリストを複製するため、結果として生じる2つのオブジェクトには同じ参照が含まれません(変更可能なオブジェクトに関する限り)。 。内部リストがその内部にさらにリスト(または辞書などの他のオブジェクト)を持っている場合、それらも複製されます。これが「ディープコピー」の「ディープ」部分です。


2

Pythonでは、リスト、タプル、辞書などのオブジェクトを通常「=」記号で別のオブジェクトに割り当てると、Pythonは参照によってコピーを作成します。つまり、次のようなリストのリストがあるとします。

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

次のように、このリストに別のリストを割り当てます。

list2 = list1

次に、Pythonターミナルでlist2を出力すると、次のようになります。

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

シャローコピーに移行しました。2つのオブジェクトがシャローコピーを介してコピーされると、両方の親オブジェクトの子オブジェクトは同じメモリ位置を参照しますが、コピーされたオブジェクトのそれ以降の新しい変更は互いに独立します。小さな例でこれを理解しましょう。次の小さなコードスニペットがあるとします。

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

さて、ディープコピーは、互いから完全に分離されたオブジェクトを作成するのに役立ちます。2つのオブジェクトがディープコピーを介してコピーされる場合、親とその子の両方が異なるメモリロケーションを指します。例:

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

以下のコードは、割り当て、copyメソッドを使用した浅いコピー、(スライス)[:]を使用した浅いコピー、およびディープコピーの違いを示しています。以下の例では、違いをより明確にすることにより、ネストされたリストを使用しています。

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

実行するGISTは次のとおりです。「通常の割り当て」を使用して浅いリスト(sub_listではなく、単一の要素のみ)を処理すると、浅いリストを作成してから「通常の割り当て」を使用してこのリストのコピーを作成すると、「副作用」が発生します。 。この「副作用」は、作成されたコピーリストの要素を変更した場合です。元のリストの同じ要素が自動的に変更されるためです。copyコピー要素を変更しても元のリスト要素は変更されないので、そのときに便利です。

一方、copyリストを含むリスト(sub_lists)があり、それをdeepcopy解決する場合にも、「副作用」があります。たとえば、ネストされたリストを含む大きなリスト(sub_lists)を作成し、この大きなリスト(元のリスト)のコピーを作成したとします。「副作用」は、大きなリストのsub_listsを自動的に変更するコピーリストのsub_listsを変更するときに発生します。場合によっては(一部のプロジェクトでは)、大きなリスト(元のリスト)を変更せずにそのままにして、その要素(sub_lists)のコピーを作成するだけです。そのための解決策はdeepcopy、この「副作用」を処理し、元のコンテンツを変更せずにコピーを作成することです。

と動作の異なる動作はcopydeep 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

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]

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

original_listとcopy_listのsub_elementsに異なるアドレスがあります

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]

0

上記かどうかはわかりませんが、.copy()が元のオブジェクトへの参照を作成することを理解することは非常に重要です。コピーしたオブジェクトを変更すると、元のオブジェクトが変更されます。.deepcopy()は新しいオブジェクトを作成し、元のオブジェクトを新しいオブジェクトに実際にコピーします。新しいディープコピーされたオブジェクトを変更しても、元のオブジェクトには影響しません。

そして、はい、.deepcopy()は元のオブジェクトを再帰的にコピーしますが、.copy()は元のオブジェクトの第1レベルのデータへの参照オブジェクトを作成します。

したがって、.copy()と.deepcopy()のコピー/参照の違いは重要です。


0

ディープコピーはネストされた構造に関連しています。リストのリストがある場合、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]コピー方法外側のリストの内容を新しいリストにコピーしますが、内側のリストはどちらのリストでも同じなので、リストの内部リストを変更すると、両方のリストに影響します。

ただし、ディープコピーを使用すると、内部リストの新しいインスタンスも作成されます。

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]


-1
>>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.

aのディープコピーではありませんlst
ジョージー
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.