在没有说深浅copy之前，先说一下变量。变量是的数据类型取决于变量的值，变量原本没有值，赋值之后的值是什么数据类型，变量就是什么数据类型。变量的值存在内存中，变量的作用就是通过变量名查找变量值。举个例子，我们每个人都有一个身份证，在身份证上有一个身份证号。在中国，所有人的身份证号都是独一无二的。我们可以把身份证号理解为内存地址，如果想知道别人的身份证号，需要看一眼。但是身份证号不只是本人一个人知道，公安局备案也有留存身份证号。我和公安局备案查询的系统都可以理解为变量，因为我们都可以找到我的身份证号。变量的赋值就是把同一个内存地址指向多个不同的变量名。

赋值

我们先创建一个变量，变量的值可以是任何数据类型，这里先用一个列表表示变量的值，为了方便后面修改变量的值。

#!/usr/bin/python3

#coding:utf-8

#吴老二个人博客~~~www.wulaoer.org

wulaoer = [1,3,4,["python","ruby","golong"],"java"]

wulaoer1 = wulaoer

print("原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

输出结果:

原列表的内存地址 2282250815880 1491758192 2282250816264 2282247959640

赋值后的内存地址 2282250815880 1491758192 2282250816264 2282247959640

我们发现，赋值前后不同的变量名的内存地址是一样的，这就代表两个变量名共用一个内存地址，修改其中一个，另一个变量必定改变。这是针对可变数据类型，如果不可变数据类型，修改其中一个代表重新分配内存地址。

#!/usr/bin/python3

#coding:utf-8

#吴老二个人博客~~~www.wulaoer.org

wulaoer = [1,3,4,["python","ruby","golong"],"java"]

wulaoer1 = wulaoer

print("原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

#列表修改

wulaoer[1]=8

print("修改后原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("修改后赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

print("#######################################分割线#################################################")

wolf='python3'

wolf1=wolf

print("字符串的内存地址",id(wolf),id(wolf[1]),id(wolf[4]),id(wolf[5]))

print("字符串的内存地址",id(wolf),id(wolf[1]),id(wolf[4]),id(wolf[5]))

#字符串修改后重新赋值

wolf=wolf.replace('3','2')

print("修改后字符串的内存地址",id(wolf),id(wolf[1]),id(wolf[4]),id(wolf[5]))

print("修改后字符串的内存地址",id(wolf),id(wolf[1]),id(wolf[4]),id(wolf[5]))

输出结果：

原列表的内存地址 1142802934152 1491758192 1142802934536 1142800069720

赋值后的内存地址 1142802934152 1491758192 1142802934536 1142800069720

修改后原列表的内存地址 1142802934152 1491758192 1142802934536 1142800069720

修改后赋值后的内存地址 1142802934152 1491758192 1142802934536 1142800069720

#######################################分割线#################################################

字符串的内存地址 1142802560144 1142799002624 1142799794896 1142799047232

字符串的内存地址 1142802560144 1142799002624 1142799794896 1142799047232

修改后字符串的内存地址 1142802561544 1142799002624 1142799794896 1142799047232

修改后字符串的内存地址 1142802561544 1142799002624 1142799794896 1142799047232

列表是可变类型，修改内存地址值后内存地址一样，字符串是不可变类型，需要把修改后的值重新赋值给变量，会重新生成一个新的内存地址。总结，赋值就是通过变量引用内存地址。

数据copy分为深copy和浅copy，两者的区别：改变原始对象中为可变类型的元素的值，会同时影响拷贝对象；改变原始对象中为不可变类型的元素的值，不会响拷贝对象。看下面的例子：

#!/usr/bin/python3

#coding:utf-8

#吴老二个人博客~~~www.wulaoer.org

import copy

wulaoer = [1,3,4,["python","ruby","golong"],"java"]

wulaoer1 = copy.copy(wulaoer)#浅copy

print("原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

wulaoer[3][0]="python3"

print("浅copy前",wulaoer)

print("浅copy后",wulaoer1)

print("原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

print("##########################修改数据########################################")

wulaoer[0]=27

print("原列表的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("赋值后的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

print("修改copy前",wulaoer)

print("修改copy后",wulaoer1)

输出结果：

原列表的内存地址 1901896845640 1491758192 1901896934088 1901893989352

赋值后的内存地址 1901896845704 1491758192 1901896934088 1901893989352

浅copy前 [1, 3, 4, ['python3', 'ruby', 'golong'], 'java']

浅copy后 [1, 3, 4, ['python3', 'ruby', 'golong'], 'java']

原列表的内存地址 1901896845640 1491758192 1901896934088 1901893989352

赋值后的内存地址 1901896845704 1491758192 1901896934088 1901893989352

##########################修改数据########################################

原列表的内存地址 1901896845640 1491758192 1901896934088 1901893989352

赋值后的内存地址 1901896845704 1491758192 1901896934088 1901893989352

修改copy前 [27, 3, 4, ['python3', 'ruby', 'golong'], 'java']

修改copy后 [1, 3, 4, ['python3', 'ruby', 'golong'], 'java']

先对比一下浅copy的前后对比，浅copy前后只有最顶层的内存地址发生了变化，嵌套的列表地址没有改变。修改嵌套的列表，浅copy的列表也跟着改变，修改外层的列表，浅copy后的列表不发生改变。

深copy

#!/usr/bin/python3

#coding:utf-8

#吴老二个人博客~~~www.wulaoer.org

import copy

wulaoer = [1,3,4,{"python":"ruby"},"java"]

wulaoer1 = copy.deepcopy(wulaoer)

wulaoer.append("DevOps")

print(wulaoer)

print(wulaoer1)

print("深copy前的内存地址 ",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("深copy后的内存地址 ",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

wulaoer[3]["golong"]="DevOPS"

print(wulaoer)

print(wulaoer1)

print("深copy前修改的内存地址",id(wulaoer),id(wulaoer[2]),id(wulaoer[3]),id(wulaoer[4]))

print("深copy后修改的内存地址",id(wulaoer1),id(wulaoer1[2]),id(wulaoer1[3]),id(wulaoer1[4]))

输出结果：

[1, 3, 4, {'python': 'ruby'}, 'java', 'DevOps']

[1, 3, 4, {'python': 'ruby'}, 'java']

深copy前的内存地址 2223699337928 1491758192 2223696350808 2223696393192

深copy后的内存地址 2223699253576 1491758192 2223699325648 2223696393192

[1, 3, 4, {'python': 'ruby', 'golong': 'DevOPS'}, 'java', 'DevOps']

[1, 3, 4, {'python': 'ruby'}, 'java']

深copy前修改的内存地址 2223699337928 1491758192 2223696350808 2223696393192

深copy后修改的内存地址 2223699253576 1491758192 2223699325648 2223696393192

深copy后第二层的数据发生了改变，和第一层完全独立了。原列表发生了改变，新列表不变。这是可变类型的深浅copy，下面看一下不可变类型的深浅copy

#!/usr/bin/python3

#coding:utf-8

#吴老二个人博客~~~www.wulaoer.org

import copy

wulaoer="python"

wulaoer1=copy.copy(wulaoer)

print(id(wulaoer),id(wulaoer1))

wulaoer="python3"

print(wulaoer,wulaoer1)

print(id(wulaoer),id(wulaoer1))

输出结果：

2298893382632 2298893382632

python3 python

2298893381960 2298893382632

浅copy的内存地址不变，修改原字符串，新字符串不会跟着改变

总结：

不论针对列表还是字典，浅拷贝时，修改的元素类型是可变类型时，他变我也变，修改的类型是不可变类型时，他变我不变。

不论针对列表还是字典，深拷贝时，他变我不变。

可变类型：字典、列表。

不可变类型：整型、字符串、元组。