copy深浅拷贝

时间 2019-12-01

标签 copy 深浅拷贝繁體版

原文原文链接

　　咱们在不少方法里都看到copy()方法，这是对变量的复制，赋值，下面来看一下实例：python

复制方法调用的是copy模块中的方法：编程

import copyapp

　　copy.copy() #前拷贝spa

　　copy.deepcopy() #深拷贝
3d

咱们可让一个变量等于另外一个变量能够采用赋值的方式，好比a = b等，让变量a = b变量，还能够经过copy()来实现。下面来看看在各类状况下的关联状况：blog

1、字符串和数字的状况ip

    >>> 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()三种方式，咱们发现采用三种方式的方式，都是把地址关联过去，具备相同的地址，说明是采用以下方式进行管理的。实例以下：
内存

从上图能够看出，在数字和字符串中，三种任意方式都是关联到字符串或数字所在的内存，是把内容关联过去，所以不管采用那种方式都是同样的字符串

。下面来看一看在列表，元组、字符串、字典中的状况。it

2、列表，元组，字典一层复制状况

列表、字典的状况

一、在列表中的状况

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))
二、在字典中的状况
　　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()方法也是同样的，图例以下：

3、列表，元组，字典多层状况的赋值状况

上面咱们研究了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"]))

运行结果以下：

{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
　　{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
　　{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
　　139928164286856 139928139772744 139928139736968
　　10918272 10918272 10918272

　　139928163731640 139928163731640 139928163731640

　　139928139736520 139928139736520 139928139737608 （k3）的ip地址

　　{'k3': [456, 'alex'], 'k1': 888, 'k2': 'wupie'}
　　{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
　　{'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
　　139928164286856 139928139772744 139928139736968
　　139928164089648 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()才会生成第二层的信息。