我们在很多方法里都看到copy()方法，这是对变量的复制，赋值，下面来看一下实例：
复制方法调用的是copy模块中的方法：
import copy
copy.copy() #前拷贝
copy.deepcopy() #深拷贝
我们可以让一个变量等于另一个变量可以采用赋值的方式，比如a = b等，让变量a = b变量，还可以通过copy()来实现。下面来看看在各种情况下的关联情况：
一、字符串和数字的情况
>>> import copy
>>> a = 3
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> b
3
>>> c
3
>>> d
3
>>> print(id(a),id(b),id(c),id(d))
10914432 10914432 10914432 10914432
从上面可以看出，我们通过导入模块copy，这个模块专门用于复制，可以看到在数字中，采用赋值、copy()、deepcopy()三种方式，我们发现采用三种方式的方式，都是把地址关联过去，具有相同的地址，说明是采用如下方式进行管理的。实例如下：
从上图可以看出，在数字和字符串中，三种任意方式都是关联到字符串或数字所在的内存，是把内容关联过去，因此无论采用那种方式都是一样的
。下面来看一看在列表，元组、字符串、字典中的情况。
二、列表，元组，字典一层复制情况
列表、字典的情况
1、在列表中的情况
import copy
l = ["alex",11,"sb","tom"]
d = {"k1":"v1","k2":22,"k3":"alex"}
t = (11,'ALEX',"sb")
l1 = l
l2 = copy.copy(l)
l3 = copy.deepcopy(l)
print(id(l),id(l1),id(l2),id(l3))
#下面来修改一下列表中的元素，看看关联情况编程什么样了，如下：
l.append("Aoi")
print(l,l1,l2,l3)
print(id(l),id(l1),id(l2),id(l3))
2、在字典中的情况
d1 = d
d2 = copy.copy(d)
d3 = copy.deepcopy(d)
print(id(d),id(d1),id(d2),id(d3))
d.__setitem__("tom","Hello")
print(d,"\n",d1,"\n",d2,"\n",d3)
print(id(d),id(d1),id(d2),id(d3))
运行结果如下：
列表中的运算结果：
140006457636360 140006457636360 140006457672456 140006457637320
['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
140006457636360 140006457636360 140006457672456 140006457637320
140006482186568 140006482186568 140006457674440 140006457636680
字典中的运算结果：
{'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
{'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
{'k2': 22, 'k1': 'v1', 'k3': 'alex'}
{'k2': 22, 'k1': 'v1', 'k3': 'alex'}
140006482186568 140006482186568 140006457674440 140006457636680
可以看出，在列表中我们通过等号赋值（=）、copy(list)、deepcopy(list)方法打印变量的ip地址，可以看出，等号赋值（=）与原来变量的地址是一样的，因此等号的赋值方式是这样的：
等号赋值无论在关联字典还是列表的过程中，都是指向同一个Python开辟的内存地址，a和b的内存地址永远是一致的，只要a发生了变化，相应的b就发生变化。
而在字典中copy()和deepcopy()确是下面的形式：
为什么我猜测copy()是上面的形式呢，我们来看一段代码：
import copy
l = ["alex",11,"sb","tom"]
d = {"k1":"v1","k2":22,"k3":"alex"} （1）
t = (11,'ALEX',"sb")
l1 = l
l2 = copy.copy(l)
l3 = copy.deepcopy(l)
print(id(l),id(l1),id(l2),id(l3))
#下面来修改一下列表中的元素，看看关联情况编程什么样了，如下：
l.append("Aoi")
print(l,l1,l2,l3)
print(id(l),id(l1),id(l2),id(l3))
d1 = d
d2 = copy.copy(d) （2）
d3 = copy.deepcopy(d)
print(id(d),id(d1),id(d2),id(d3)) （3）
d.__setitem__("tom","Hello")
print(d,"\n",d1,"\n",d2,"\n",d3)
print(id(d),id(d1),id(d2),id(d3)) （4）
del d["k1"] （5）
print(d,"\n",d1,"\n",d2,"\n",d3)
print(id(d),id(d1),id(d2),id(d3)) （6）
代码运行如下：
140353118074376 140353118074376 140353118110472 140353118074760
['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
140353118074376 140353118074376 140353118110472 140353118074760
140353142624584 140353142624584 140353118112456 140353118075272
{'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
{'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
{'k1': 'v1', 'k2': 22, 'k3': 'alex'}
{'k1': 'v1', 'k2': 22, 'k3': 'alex'}
140353142624584 140353142624584 140353118112456 140353118075272
{'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
{'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
{'k1': 'v1', 'k2': 22, 'k3': 'alex'}
{'k1': 'v1', 'k2': 22, 'k3': 'alex'}
140353142624584 140353142624584 140353118112456 140353118075272
在上面（1）处我们定义了一个字典，在（2）处我们使用copy.copy()产生一个新的变量d2，然后我们打印变量d、d2的id(d)、id(d2)，我们可以看出，两者的id()是不一样的，因此可以说明在系统中是存在了两个位置存放d和d2的，而不是一个位置，仅凭这一点还不足以说明，下面来看（5）处，我们删除了字典d中的键-值对"k1"，此时如果两者存在关联的话，那么d2中键-值对"k1":"v1"必然也会被删除，事实上并没有，而且我们修改元素的时候，如果它们之间存在指向关系的话，那么copy()也会让d2中的添加一个键-值对"tom":"Hell0"。事实上并没有，所以我断定，无论怎样使用copy()方法都是在内存中新开辟了一个地址，如果只有一层的话，这两个地址之间也是没有关联的。
如果字典只有一层，那么使用deepcopy()方法也是一样的，图例如下：
三、列表，元组，字典多层情况的赋值情况
上面我们研究了copy()、deepcopy()单层的情况,下面来看看多层的情况,首先定义一个字典n1={"k1":123,"k2":"wupie","k3":[123,"alex"]}
,
在python中，copy()、deepcopy()的设置挺复杂的，相同元素的id是一样的，但是在删除的时候又不会影响由copy()、deepcopy()产生的变量，
但是在使用copy()的时候，第二层的元素还是与原来的元素关联在一起，下面来看一个例子：
import copy
n1 = {"k1":123,"k2":"wupie","k3":[456,"alex"]}
#打印k1的ip地址
n2 = copy.copy(n1)
n3 = copy.deepcopy(n1)
print(n1,"\n" ,n2,"\n",n3)
print(id(n1),id(n2),id(n3))
print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"\n")
#打印k2的地址
print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"\n")
#打印"k3"的ip地址
print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"\n")
#修改“k1"的值
n1["k1"] = 888
#打印修改后的信息
print(n1,"\n" ,n2,"\n",n3)
print(id(n1),id(n2),id(n3))
print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"\n")
#打印修改后的k2的地址
print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"\n")
#打印"k3"的ip地址
print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"\n")
#修改"k3"中的值
n1["k3"][0] = 666
print(n1,"\n" ,n2,"\n",n3)
print(id(n1),id(n2),id(n3))
print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"\n")
#打印修改后的k2的地址
print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"\n")
#打印"k3"的ip地址
print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"\n")
#删除"k3"的键值对
del n1["k3"]
print(n1,"\n" ,n2,"\n",n3)
print(id(n1),id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"\n")
#打印修改后的k2的地址
print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"\n")
try:#打印"k3"的ip地址
print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"\n")
except KeyError:
print(id(n2["k3"]),id(n3["k3"]))id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"\n")#打印修改后的k2的地址print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"\n")try:#打印"k3"的ip地址 print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"\n")except KeyError: print(id(n2["k3"]),id(n3["k3"]))
运行结果如下：
10918272 10918272
139928163731640 139928163731640 139928163731640
139928139736520 139928139736520 139928139737608
{'k3': [666, 'alex'], 'k1': 888, 'k2': 'wupie'}
{'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
139928164286856 139928139772744 139928139736968
139928164089648 10918272 10918272
139928163731640 139928163731640 139928163731640
139928139736520 139928139736520 139928139737608
{'k1': 888, 'k2': 'wupie'}
{'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
139928164286856 139928139772744 139928139736968
139928164089648 10918272 10918272
139928163731640 139928163731640 139928163731640
139928139736520 139928139737608
在上面例子中，我们首先定义了一个变量n1,里面嵌套了一层字典，然后使用copy(),deepcopy()生成了新的变量n2,n3并且打印了n1,n2,n3的ip地址，由ip地址可以看出，n1,n2,n3是在内存中有不同的存储位置的，接着我们打印了键-值对“k1”的存储id，结果发现，三者的“k1”存储的id位置是一样的，说明还是用的原来位置的id,这样节省了内存，接着我们看“k3”的ip地址，可以看出，使用copy()得到的ip地址与n1的“k3”的id是一样的，说明是用的一个id，我们修改字典n1中的元素"k3"之后，n2也跟着变化，说明字典n1中的“k3”和字典n2中的“k3”存在某种管理，但是当我们删除字典n1中的“k3”之后，字典n2中的"k3"不受影响，还存在，说明使用copy()生成的变量，第二层关联之间存在着某种关联，但是又不完全依存，第一层之间共用一个地址，节省了内存，但是在原来的字典发生变化的时候又不影响之前的变量，只是对新的变量开辟了一个空间，用来存放位置。
有一个监控模板，包含内存，硬盘，有一批机器，现在是按dic模式运行的，现在要修改其中一部分的及其的硬盘，其他部分不改变。
import copy
dic = {
"cpu":[80,],
"men":[80,],
"disk":[80]
}
print("before:",dic)
new_dic = copy.deepcopy(dic)
new_dic["cpu"][0] = 50
print(dic,"\n",new_dic)
在上面，我们使用copy模块的deepcopy来进行处理，我们知道，有很多信息，在嵌套中，只有deepcopy()才会生成第二层的信息。
