python copy.copy和copy.deepcopy

总的来讲，就是copy.copy复制了对象，对于对象里的元素，仍然保持引用。

copy.deepcopy不只复制了对象，也复制了对象里的元素，而不是引用。

1、前奏：熟悉Python内存管理

在Python中，变量在第一次赋值时自动声明，在建立---也就是赋值的时候，解释器会根据语法和右侧的操做数来决定新对象的类型。

引用计数器：一个内部跟踪变量

引用计数：每个对象各有多少个引用

当对象被建立并(将其引用)赋值给变量时，该对象的引用计数就被设置为 1

>>> x = 3.14

语句 x=3.14，建立一个浮点型对象并将其引用赋值给了x,x是第一个引用，该对象的引用计数为1

当一个对象(的引用)又被赋值到其余变量，或作参数传递等，该对象的一个新的引用(或叫别名)被建立，则该对象的引用计数自动+1。

如下都会增长引用计数：

y = x   #作别名
foo(x)  #作参数传递
mylis = [1,2,x,'a'] #成为容器对象的一个元素

 

如下都会减小引用计数：

del x   #del显式销毁

bar = x 
x = True    #对象的一个别名被赋值给其余对象

mylis.remove(x) #对象被从窗口对象中移除

del mylis   #窗口对象自己被销毁

 

2、Python的复制

从上面可见，对象的赋值其实是对象的引用。当建立一个对象，而后把它赋给另外一个变量的时候，python并无拷贝这个对象，而只是拷贝了这个对象的引用。

当你对一个对象赋值的时候(作为参数传递,或者作为返回值),Python和Java同样,老是传递原始对象的引用,而不是一个副本。

"""传递原始对象的引用,而不是一个副本"""
a = [1,2,3]
b = a
b.append(100)
print b         #[1, 2, 3, 100]
print a         #[1, 2, 3, 100]
print id(a)     #11530368
print id(b)     #11530368 

如 果你想修改一个对象,并且想让原始的对象不受影响,那你就须要对象复制。

能够 使用copy.copy(),它能够进行对象的浅复制(shallow copy),它复制了对象,但对于对象中的元素,依然使用引用.

(1)、使用切片[:]操做进行拷贝

(2)、使用工厂函数(如list/dir/set)等进行拷贝

(3)、copy.copy()

>>> jack = ['jack',['age',20]]
>>> tom = jack[:]
>>> anny = list(jack)
>>> jack
['jack', ['age', 20]]
>>> tom
['jack', ['age', 20]]
>>> anny
['jack', ['age', 20]]
>>> print id(jack),id(tom),id(anny)
13457088 18487376 18489136

接下来修改上面例子，对姓名和年级进行修改：

>>> tom[0]='tom'
>>> anny[0]='anny'
>>> print tom
['tom', ['age', 20]]
>>> print anny
['anny', ['age', 20]]
>>> anny[1][1]
20
>>> anny[1][1]= 18
>>> anny[1][1]
18
>>> print jack,tom,anny
['jack', ['age', 18]] ['tom', ['age', 18]] ['anny', ['age', 18]]

发现，虽然姓名都对号了，可是年龄却都变成了18.这是为何呢？

咱们看看它们元素的id

>>> [id(x) for x in jack]
[13463040, 13456608]
>>> [id(x) for x in tom]
[13463424, 13456608]
>>> [id(x) for x in anny]
[18501664, 13456608]

发现，其中列表中  姓名字符串  id都不同，可是 年龄列表id却都相同。

这是由于：python中字符串不能够修改，因此在为tom和anny从新命名的时候，会从新建立一个’tom’和’anny’对象，替换旧的’jack’对象。

这就说明了，浅复制(shallow copy),它复制了对象,但对于对象中的元素,依然使用引用.

"""浅copy"""
import copy
aa = [1,2,3]
bb = copy.copy(aa)
print id(aa)    #11533088
print id(bb)    #12014776
bb[0] =100
print bb        #[100, 2, 3]
print aa        #[1,2,3]
#因为数字不可变，修改的时候会替换旧的对象
print [id(x) for x in bb]   #[10247196, 10246388, 10246376]
print [id(y) for y in aa]   #[10246400, 10246388, 10246376]

下面试试对象中可变元素：

lis = [['a'],[1,2],['z',23]]
copyLis = copy.copy(lis)
copyLis[1].append('bar')
print copyLis   #[['a'], [1, 2, 'bar'], ['z', 23]]
print lis       #[['a'], [1, 2, 'bar'], ['z', 23]]

若是但愿复制一个容器对象,以及它里面的全部元素(包含元素的子元素),使用copy.deepcopy,这个方法会消耗一些时间和空间,不过,若是你须要彻底复制,这是惟一的方法.

"""深copy"""
deepLis = copy.deepcopy(lis)
deepLis[1].append('foo')    
print deepLis   #[['a'], [1, 2,'foo'], ['z', 23]]
print lis       #[['a'], [1, 2], ['z', 23]]

注意：

一、对于非容器类型(如数字、字符串、和其余‘原子’类型的对象)没有被拷贝一说。

二、若是元祖变量只包含原子类型对象，则不能深copy。

参考：http://blog.csdn.net/sharkw/article/details/1934090

http://www.01happy.com/python-shallow-copy-and-deep-copy/