[Python] 等号赋值, copy, deepcopy的区别

参考链接：

1. 介绍python中的可变类型与不可变类型：https://blog.csdn.net/answer3lin/article/details/86430074

(也可以参考转载博客 Python中的不可变对象类型与可变对象类型)

2. 介绍等号赋值、copy、deepcopy的区别：https://blog.csdn.net/qq_26442553/article/details/82218403

建议读者首先明白python中变量的本质、可变对象类型与不可变对象类型的区别，之后对于深浅拷贝会容易理解。

---

1. 等号"="

“=”的作用是引用原对象的在内存中的地址，让新对象指向这个地址。

1.1 不可变对象

对于不可变对象，其值本身不允许被修改，数值的修改实际上是让变量指向了一个新的对象（新创建的对象）。

图1. 不可变对象类型"="拷贝

 # 1.使用=复制不可变对象的值，以及复制以后修改其值后的变化。
 val1 = 1000
 val2 = val1
 print("val1 is :{0},val2 is :{1}".format(val1,val2))
 # val1 is :1000,val2 is :1000
 print(id(val1),id(val2))
 # 139692380387760 139692380387760

 # 修改val1的值，因为val1是不可变类型，修改其值，会重新给新值分配内存，然后指向他。
 val1 += 1
 print(val1,id(val1),val2,id(val2))
 # 1001 139692380387216 1000 139692380387760

1.2 可变对象类型

对于可变对象类型，"="会引用对象地址，对其进行修改，只会改变对象值的内容，并不修改该对象（不创建新对象，不更改指针指向的地址）。

Tips:

list对象的地址和list[0]对象的地址是不同的。可以理解为list这个组合对象中插入的是其中各个对象的地址的引用。

图2. list对象

 #1.使用=复制可变对象的值，以及复制以后修改其值后的变化。
 ls1 =[1,2,3,4]
 ls2 = ls1
 print(id(ls1),id(ls2))
 # 140520429283400 140520429283400
 # 直接使用=复制变量，内存地址一样，值也一样。
 print(ls1,ls2)
 #[1, 2, 3, 4] [1, 2, 3, 4]
 #直接使用=复制变量，内存地址一样，值也一样。
 #这时候修改可变对的值,因为其值可变，所以只需要在原内存地址上修改即可。
 ls1.append(5)
 print(id(ls1),id(ls2))
 # 140520429283400 140520429283400
 #可变对象修改其值，内存引用不变
 print(ls1,ls2)
 #[1, 2, 3, 4, 5] [1, 2, 3, 4, 5] 因为两个变量的内存指向一样，所以值也一样。

 print(id(ls1), id(ls2))
 print(id(ls1[0]), id(ls2[0]))
 print(id(ls1[1]), id(ls2[1]))
 print(id(ls1[2]), id(ls2[2]))
 # 140520429283400 140520429283400
 # 94472536902176 94472536902176
 # 94472536902208 94472536902208
 # 94472536902240 94472536902240

2. copy

2.1 不可变对象类型

效果同"="中的不可变对象

2.2 可变对象类型

对于copy一个可变对象类型的对象，会重新创建一个新的对象，如果原对象是一个组合对象(比如list, 类实例等)，会将原组合对象中的各个对象的引用插入到新创建的对象中。

注意，copy只是将其第一层组成对象的内存地址引用过来，并不迭代的引用组成对象的组成对象的地址！所以，如果其组成对象是可变类型，虽然引用地址不变，但其内容可能会变化。详见下面两个例子：

例1.

 import copy
 ls1 =[1,2,3,4]
 ls2 = copy.copy(ls1)
 print(id(ls1), id(ls2))
 # 140616587448072 140616587497224

 ls1.append(5)
 print(ls1,ls2)
 #[1, 2, 3, 4, 5] [1, 2, 3, 4]

 print(id(ls1), id(ls2))
 print(id(ls1[0]), id(ls2[0]))
 # 140616587448072 140616587497224
 # 94889387870752 94889387870752

例2.

 origin = [1, 2, [3, 4]]
 cop1 = copy.copy(origin)
 origin[2][0] = "hey!"  #修改数据源的值
 print(cop1)
 #[1, 2, ['hey!', 4]]

对于例2的解释

  

图3. origin = [1, 2, [3, 4]]的内部结构                                               图4. copy的实现

可以看出copy只在新对象中插入了第一层的地址引用. 其中只有有橘色框的对象是新建的对象。

那么如果想要拷贝前后两个对象完全互相独立，互不影响要怎样做呢？用deepcopy，递归地将组合对象内部的对象进行深层引用。

3. deepcopy

copy与deepcopy的区别：

The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):

• A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.

• A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

 origin = [1, 2, [3, 4]]
 cop2 = copy.deepcopy(origin)
 origin[2][0] = "hey!"  #修改数据源的值
 print(cop2) # [1, 2, [3, 4]]

对比2.2的例2会发现deepcopy递归的将组合对象的每一层的对象都进行了复制。因此，original的对象与deep copy之后的对象是内存地址完全不同的，完全独立的。

         

图3. origin = [1, 2, [3, 4]]的内部结构                             图4. copy的实现                                                                              图5. deepcopy与copy实现的对比

其中橘色是deepcopy实现，不仅新建了第一层addr9处的对象，也递归地新建了addr10处的对象，并将addr10引用插入到addr9处的对象中；递归到指向不可变类型的对象为止；因而原对象与新对象是完全独立，互不影响的。

其中绿色是copy实现，仅新建了第一层addr8处的对象，直接将addr5处对象的引用插入到addr8中，并没有为其重新开辟空间，新建对象，因而，原对象中更深层次中内容的变换，会直接影响新对象内容，二者并非完全独立。

所以，慎用copy～