python深拷贝和浅拷贝

gsbyqjkwdg

简单点说 　　1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 　　用一个简单的例子说明如下： 　　>>>import copy >>>a = [1, 2, 3, 4, ['a', 'b', 'c']] >>> b = a >>> c = copy.copy(a) >>> d = copy.deepcopy(a) 　　很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。 　　第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同： 　　>>> id(a) 19276104 >>> id(b) 19276104 >>> id(c) 19113304 >>> id(d) 19286976 　　至于如何看深/浅拷贝的区别，可以通过下面的操作来展现： 　　>>> a.append(5)    #操作1 >>> a[4].append('hello')   #操作2 　　这时再查看结果： 　　>>> a [1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5] >>> b [1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5] >>> c [1, 2, 3, 4, ['a', 'b', 'c', 'hello']] >>> d [1, 2, 3, 4, ['a', 'b', 'c']] 　　可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ ['a', 'b', 'c', 'hello']）改变时会影响到c；d是深拷贝，完全不受a的影响

简单点说 　　1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 　　用一个简单的例子说明如下： 　　>>>import copy >>>a = [1, 2, 3, 4, ['a', 'b', 'c']] >>> b = a >>> c = copy.copy(a) >>> d = copy.deepcopy(a) 　　很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。 　　第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同： 　　>>> id(a) 19276104 >>> id(b) 19276104 >>> id(c) 19113304 >>> id(d) 19286976 　　至于如何看深/浅拷贝的区别，可以通过下面的操作来展现： 　　>>> a.append(5)    #操作1 >>> a[4].append('hello')   #操作2 　　这时再查看结果： 　　>>> a [1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5] >>> b [1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5] >>> c [1, 2, 3, 4, ['a', 'b', 'c', 'hello']] >>> d [1, 2, 3, 4, ['a', 'b', 'c']] 　　可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ ['a', 'b', 'c', 'hello']）改变时会影响到c；d是深拷贝，完全不受a的影响

　　简单点说
　　1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
2. copy.deepcopy 深拷贝 拷贝对象及其子对象
　　用一个简单的例子说明如下：
　　>>>import copy
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
　　很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。
　　第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同：
　　>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976
　　至于如何看深/浅拷贝的区别，可以通过下面的操作来展现：
　　>>> a.append(5)    #操作1
>>> a[4].append('hello')   #操作2
　　这时再查看结果：
　　>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]
　　可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ ['a', 'b', 'c', 'hello']）改变时会影响到c；d是深拷贝，完全不受a的影响

?

　　
　　===========
　　浅拷贝是指拷贝的只是原对象元素的引用，换句话说，浅拷贝产生的对象本身是新的，但是它的内容不是新的，只是对原对象的一个引用。这里有个例子
>>> aList=[[1, 2], 3, 4]
>>> bList = aList[:] #利用切片完成一次浅拷贝
>>> id(aList)
3084416588L
>>> id(bList)
3084418156L
>>> aList[0][0] = 5
>>> aList
[[5, 2], 3, 4]
>>> bList
[[5, 2], 3, 4]
可以看到，浅拷贝生产了一个新的对象bList,但是aList的内容确实对aList的引用，所以但改变aList中值的时候，bList的值也跟着变化了。
但是有点需要特别提醒的，如果对象本身是不可变的，那么浅拷贝时也会产生两个值，见这个例子：
>>> aList = [1, 2]
>>> bList = aList[:]
>>> bList
[1, 2]
>>> aList
[1, 2]
>>> aList[1]=111
>>> aList
[1, 111]
>>> bList
[1, 2]
为什么bList的第二个元素没有变成111呢？因为数字在python中是不可变类型！！
这个顺便回顾下Python标准类型的分类：
可变类型： 列表，字典
不可变类型：数字，字符串，元组
理解了浅拷贝，深拷贝是什么自然就很清楚了。
python中有一个模块copy，deepcopy函数用于深拷贝，copy函数用于浅拷贝。
最后，对象的赋值是深拷贝还是浅拷贝？
对象赋值实际上是简单的对象引用
>>> a = 1
>>> id(a)
135720760
>>> b = a
>>> id(b)
135720760
a和b完全是一回事。