Python深浅copy

在python里对对象进行拷贝有三个，即赋值，深拷贝，浅拷贝。而对象又分为两种，一种是不可变对象(字符串、元组、数字 )，一种是可变对象(列表、字典)。而深浅拷贝有三种情况：

1. 拷贝的是不可变对象，对于不可变对象来说，深浅拷贝都一样的，即便是用深拷贝，也都是一样的id，如果要重新赋值，也只是创建一个新的对象，替换旧的对象。所以对于不可变对象来说，不管怎么拷贝，它的地址、值都是一样的。
2. 拷贝的是可变对象

import copy
a=3
b=copy.copy(3)
c=copy.deepcopy(3)
print(a,b,c)  #3,3,3，
print(id(a)==id(b)==id(c))  #true

4. 拷贝的可变对象里面还有子对象

import copy
a=[1,2,3,[4,5,6]]#1,2,3 是第一层，[4,5,6]是第二层
b=a
c=copy.copy(a)#当浅copy的时候，第一层是新的，第二层还是原来的地址
d=copy.deepcopy(a)#当用深copy的时候，所有的内容都是新的，所以不会影响地址

print(id(a)==id(b))  #true
print(id(a)==id(c))  #false
print(id(a)==id(d))  #false
print(id(c)==id(d))  #false

下面用栈和堆来解释这个深浅copy。

1.下面的程序是一个简单的把赋值相等的函数

c=[1,2,3]
d=c
c[0]=100
print（c==d）     #true

用栈和堆是如下图：

这是是一个简单把c的值赋给d，就是把c在栈中存放[1,2,3,]在堆中的地址传给d。

2.浅copy的程序如下

import  copy
a=[1,2,3]
b=copy.copy(a)
a[0]=100
print(a==b)      #flase

用栈和堆的图形表示为

浅拷贝只是把【1,2,3】的值在堆里重新开辟的内存把【1,2,3,】放进去，b在栈里存放的【1,2,3】在堆里的地址和a在栈里存放的【1,2,3,】在堆里的地址是两个完全不同的地址。
a 的值得变换不回影影响b的值

如果是嵌套列表，在浅copy里，嵌套列表值改变会影响复制的值

import copy
a=[[1,2],3,4]
b=copy.copy(a)
a[0][0]=100
print(b)     #[[100,2],3,4]

用栈和堆的图示来表示的入下图：

b只是copy了【0xf001,3,4】,但是没有copy【1,2】，所以【1,2】在堆里的地址还是原地址，所以1换成100，b的值也是[[100,2],3,4]

当浅copy的时候，第一层是新的，第二层还是原来的地址。

3.深copy：

import copy
a=[1,2,[3,4]]
b=copy.deepcopy(a)
a[2][0]=300
print(a)   # [1, 2, [300, 4]]
print(b)    #[1, 2, [3, 4]]

输出结果a=[1, 2, [300, 4]], b=[1, 2, [3, 4]]
具体如下图：

当用深copy的时候，所有的地址都是新的，所以不会影响地址，所以a[2][0]的改变不会影响b[2][0]的值改变，因为堆地址完全不一样。