Python深复制浅复制or深拷贝浅拷贝

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的影响

#!/usr/bin/env python3

#antuor:Alan

import copy
# 数字, 字符串
print('-----------------------------------数字---------------------------------')
a1 = 123           ###赋值
a2 = 123
print (id(a1))
print ('数字赋值:',id(a2))
print('-----------------------------------字符串---------------------------------')
a3 = 'asd'
a4 =a3
print (id(a3))
print ('字符串赋值:',id(a4))
print('-----------------------------------数字,字符串深浅拷贝---------------------------------')
a5 = 'alan'
a6 =copy.copy(a5)       ###浅拷贝
a7 =copy.deepcopy(a5)   ###深拷贝
print (id(a5))
print ('字符串浅拷贝:',id(a6))
print ('字符串深拷贝:',id(a7))

"""字符串和数字,对这三种方法,用的是同一个内存地址"""

print('-----------------------------------元祖,列表,字典---------------------------------')
print('---------------------字典-------------------------')
n1 = {'k1':'wu','k2':133,'k3':['alan',123]}
n2 =n1
print(id(n1))
print('字典赋值:',id(n2))
n3 = copy.copy(n1)     ###只拷贝第一层
n4 = copy.deepcopy(n1) ###深拷贝
print('字典浅拷贝:',id(n3))
print('字典深拷贝:',id(n4))
print('---------------------第1层-------------------------')
print(id(n1['k1']))
print('深浅拷贝第一层:',id(n3['k1']))
print('深浅拷贝第一层:',id(n4['k1']))

print('---------------------第2层-------------------------')
print(id(n1['k3'][1]))
print('浅拷贝第二层:',id(n3['k3'][1]))
print('深拷贝第二层:',id(n4['k3'][1]))

print('-----------------------------------浅拷贝应用---------------------------------')
dic = {
    "cpu":[80,],
    "mem":[80,],
    "disk":[80,]
}

print("原数据:",dic)
new_copy_dic = copy.copy(dic)
new_copy_dic['cpu'][0] = 50    ###因为新数据是对旧数据的浅拷贝,只拷贝父对象,不拷贝子对象,所以新子对象变影响旧,旧子对象影响新
print("浅拷贝后原数据:",dic)
print("浅拷贝数据:",new_copy_dic)

print('-----------------------------------深拷贝应用---------------------------------')
#################################应用: 深拷贝###########################
dic = {
    "cpu":[80,],
    "mem":[80,],
    "disk":[80,]
}
print("原数据:",dic)
new_deepcopy_dic = copy.deepcopy(dic)
new_deepcopy_dic['cpu'] = 90
print("深拷贝后原数据:",dic)
print("深拷贝数据:",new_deepcopy_dic)

　　

===========

浅拷贝是指拷贝的只是原对象元素的引用，换句话说，浅拷贝产生的对象本身是新的，但是它的内容不是新的，只是对原对象的一个引用。这里有个例子
>>> 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完全是一回事