python深拷贝和浅拷贝

一、含义

浅拷贝：只拷贝了父对象的元素，不拷贝其父对象引用，但会拷贝其子对象的引用。(只拷贝第一层)

深拷贝：将对象的所有都拷贝了一份，与原对象完全不相干。（克隆一份，也就是完全复制一份）

二、浅拷贝

alist=[1,2,3,["a","b"]]

1）直接赋值,传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变

>>> b=alist
>>> print b
[1, 2, 3, ['a', 'b']]
>>> alist.append(5)  #copy.copy(alist)
>>> print alist;print b
[1, 2, 3, ['a', 'b'], 5]
[1, 2, 3, ['a', 'b'], 5]

（2）copy浅拷贝，没有拷贝子对象，所以原始数据改变，子对象会改变

>>> import copy

>>> c=alist.copy()  #copy.copy(alist)
>>> print alist;print c
[1, 2, 3, ['a', 'b']]
[1, 2, 3, ['a', 'b']]
>>> alist.append(5)
>>> print alist;print c
[1, 2, 3, ['a', 'b'], 5]
[1, 2, 3, ['a', 'b']]

>>> alist[3]
['a', 'b']
>>> alist[3].append('cccc')
>>> print alist;print c
[1, 2, 3, ['a', 'b', 'cccc'], 5]
[1, 2, 3, ['a', 'b', 'cccc']] 里面的子对象被改变了

三、深拷贝

alist=[1,2,3,["a","b"]]

1）深拷贝，包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变

>>> import copy

>>> d=copy.deepcopy(alist)
>>> print alist;print d
[1, 2, 3, ['a', 'b']]
[1, 2, 3, ['a', 'b']]始终没有改变
>>> alist.append(5)
>>> print alist;print d
[1, 2, 3, ['a', 'b'], 5]
[1, 2, 3, ['a', 'b']]始终没有改变
>>> alist[3]
['a', 'b']
>>> alist[3].append("ccccc")
>>> print alist;print d
[1, 2, 3, ['a', 'b', 'ccccc'], 5]
[1, 2, 3, ['a', 'b']]  始终没有改变

 

练习：

浅拷贝：只拷贝一层,顶层

深拷贝：全部拷贝：递归拷贝

浅拷贝(copy.copy)拷贝元组，那么它不会进行拷贝，仅仅指向，原因：因为元组是不可变类型，那么意味着数据一定不能修改，因此用copy.copy的时候它会自动判断，如果是是元组就指向它

如果用copy.copy、copy.deepcopy对一个全部都是不可变类型的数据进行拷贝，那么他们结果相同，都是引用指向
如果拷贝的是一个拥有可变的数据，及时元组是最顶层，那么copy.deepcopy还是深拷贝，copy.copy依然是指向

如果用copy.copy、copy.deepcopy对一个全部都是不可变类型的数据进行拷贝，那么他们结果相同，都是引用指向
如果拷贝的是一个拥有可变的数据，及时元组是最顶层，那么copy.deepcopy还是深拷贝，copy.copy依然是指向

列表的切片和字典，函数也是浅拷贝

__author__ = 'Administrator'
import copy


a = [11,22]
b = [33,44]
c = [a,b]
#浅拷贝：只拷贝一层,顶层
d = copy.copy(c)
#深拷贝：全部拷贝：递归拷贝
e = copy.deepcopy(c)
a.append(55)
print(c,id(c),id(c[0]))
print(d,id(d),id(d[0]))
print(e,id(e),id(e[0]))
"""
[[11, 22, 55], [33, 44]] 54801792 54800792
[[11, 22, 55], [33, 44]] 54801752 54800792
[[11, 22], [33, 44]]     54801712 54801672
"""

#浅拷贝(copy.copy)拷贝元组，那么它不会进行拷贝，仅仅指向
# 原因：因为元组是不可变类型，那么意味着数据一定不能修改，
# 因此用copy.copy的时候它会自动判断，如果是是元组就指向它
f = (11,22)
g = copy.copy(f)
h = copy.deepcopy(f)
print(f,id(f))
print(g,id(g))
print(h,id(h))
"""
(11, 22) 54512536
(11, 22) 54512536
(11, 22) 54512536
"""

#如果用copy.copy、copy.deepcopy对一个全部都是不可变类型的数据进行拷贝，那么他们结果相同，都是引用指向
#如果拷贝的是一个拥有可变的数据，及时元组是最顶层，那么copy.deepcopy还是深拷贝，copy.copy依然是指向
x = [11,22]
y = [33,44]
z = (x,y)
zz = copy.copy(z)
yy = copy.deepcopy(z)
x.append(33)
print(z,id(z))
print(zz,id(zz))
print(yy,id(yy))
"""
([11, 22, 33], [33, 44]) 54554952
([11, 22, 33], [33, 44]) 54554952
([11, 22], [33, 44]) 54554992
"""

#列表的切片和字典也是浅拷贝
a = [11,22]
b = [33,44]
c = [a,b]
d = c[:]  # c[:] 与copy.copy(c)一样，属于浅拷贝
a.append(55)
print(c,id(c),id(c[0]))
print(d,id(d),id(d[0]))
"""
[[11, 22, 55], [33, 44]] 59257800 59257880
[[11, 22, 55], [33, 44]] 59258240 59257880
"""


#函数形参
def test_num(temp):
    temp.append(33)

num=[11,22]
test_num(num)
print(num)
"""
[11, 22, 33]
"""

#函数形参
def test_num1(temp):
    temp.append(33)
j=[11,22]
test_num1(copy.deepcopy(j))
print(j)
"""
[11, 22]
"""