先看看浅拷贝的概念:
-
浅拷贝:对一个对象进行浅拷贝其实是新创建了一个类型跟原对象一样,其内容还是原来对象元素的引用,换句话说,这个拷贝的对象本身是新的,但是它的内容不是
序列类型对象的浅拷贝是默认类型拷贝,有以下几种实现方式:
-
完全切片操作:下面操作会有
-
利用工厂函数:比如list()、dict()等
-
使用copy模块的copy()函数
其实如果是真正理解了Python对象或者说理解了可变对象和不可变对象,再根据上面的理论知识,浅拷贝和深拷贝基本上算是比较好的掌握了。所以这里不按照书上(指的是《Python核心编程》)的思路来进行总结,当然书上的例子作为入门也是非常不错的。下面给出三个例子,如果都可以理解,那么对Python浅拷贝和深拷贝的掌握到这个程度也就可以了。
1.第一个例子:列表中的元素都是原子类型,即不可变对象
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> person
=
[
'age'
,
20
]
>>> xpleaf
=
person[:]
#浅拷贝
>>> cl
=
list
(person)
#浅拷贝
>>> [
id
(x)
for
x
in
person, xpleaf, cl]
#虽然是浅拷贝,但是其实也是生成了新的对象
[
140205544875144
,
140205544893688
,
140205544996232
]
>>> [
id
(x)
for
x
in
person]
[
140205545021232
,
32419728
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205545021232
,
32419728
]
>>> [
id
(x)
for
x
in
cl]
[
140205545021232
,
32419728
]
#但是可以看到列表中的元素的还是原来对象元素的引用
|
上面做了浅拷贝的操作,然后下面修改两个浅拷贝的值:
1
2
3
4
5
6
7
8
9
10
|
>>> xpleaf[
1
]
=
22
>>> cl[
1
]
=
21
>>> person, xpleaf, cl
([
'age'
,
20
], [
'age'
,
22
], [
'age'
,
21
])
>>> [
id
(x)
for
x
in
person]
[
140205545021232
,
32419728
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
cl]
[
140205545021232
,
32419704
]
|
修改了两个浅拷贝的值,然后发现内容并没有相互影响,而且后来的id值也发生改变了,怎么会这样?不要忘了,列表中的元素都是不可变对象,修改不可变对象的值,其实就相当于是新生成了一个该对象,然后让列表元素重新指向新生成的不可变对象,在这里是数字对象。
理解这个例子本身并不难,但需要对Python对象和序列类型本身有一定的理解。
2. 第二个例子:列表中包含容器类型变量,即可变对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
>>> person
=
[
'name'
, [
'age'
,
20
]]
>>> xpleaf
=
person[:]
>>> cl
=
list
(person)
>>> person, xpleaf, cl
([
'name'
, [
'age'
,
20
]], [
'name'
, [
'age'
,
20
]], [
'name'
, [
'age'
,
20
]])
>>> [
id
(x)
for
x
in
person, xpleaf, cl]
[
140205544995944
,
140205544893688
,
140205544875144
]
# 查看大列表的元素id值
>>> [
id
(x)
for
x
in
person, xpleaf, cl]
[
140205544996160
,
140205544875144
,
140205544996520
]
>>> [
id
(x)
for
x
in
person]
[
140205546176112
,
140205544995944
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205546176112
,
140205544995944
]
>>> [
id
(x)
for
x
in
cl]
[
140205546176112
,
140205544995944
]
# 查看小列表的元素id值
>>> [
id
(x)
for
x
in
person[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
xpleaf[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
cl[
1
]]
[
140205545021232
,
32419680
]
|
三个列表的第一个元素的id值都是一样的,这是引用传递,没有什么问题,跟第一个例子类似,因此修改这个值不会有什么问题。但注意看第二个元素,它是一个列表,可以肯定的是,三个列表中的两个元素的id也肯定是相同的,也是引用传递的道理,但现在关键是看第二个元素,也就是这个列表本身,三个大列表(指的是person这个列表)中的这三个小列表的id值都是一样的,于是,浅拷贝对于对象值的影响就会体现出来了,我们尝试去修改其中一个小列表中的值:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> xpleaf[
1
][
1
]
=
22
>>> person, xpleaf, cl
([
'name'
, [
'age'
,
22
]], [
'name'
, [
'age'
,
22
]], [
'name'
, [
'age'
,
22
]])
>>> [
id
(x)
for
x
in
person, xpleaf, cl]
[
140205544995944
,
140205544893688
,
140205544875144
]
# 查看大列表的元素id值
>>> [
id
(x)
for
x
in
person]
[
140205546176112
,
140205544995944
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205546176112
,
140205544995944
]
>>> [
id
(x)
for
x
in
cl]
[
140205546176112
,
140205544995944
]
# 查看小列表的元素id值
>>> [
id
(x)
for
x
in
person[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
xpleaf[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
cl[
1
]]
[
140205545021232
,
32419680
]
|
可以看到问题就出来了,即对一个小列表进行修改,会影响到其它的小列表。我们先抛开所谓的浅拷贝,去思考这个问题本身:有可能不会影响其它小列表吗?肯定没有可能的,因为三个小列表的id都一样,三个小列表里的元素的id也一样,即其实这三个小列表是完全指向同一个对象的,因此,无论修改哪一个,肯定都会影响其它小列表的。
这就是所谓浅拷贝出现的问题。
3.第三个例子:使用深拷贝来解决第二个例子出现的问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
>>> person
=
[
'name'
, [
'age'
,
20
]]
>>> xpleaf
=
person[:]
>>>
from
copy
import
deepcopy as dcp
>>> cl
=
dcp(person)
>>> person, xpleaf, cl
([
'name'
, [
'age'
,
20
]], [
'name'
, [
'age'
,
20
]], [
'name'
, [
'age'
,
20
]])
>>> [
id
(x)
for
x
in
person, xpleaf, cl]
[
140205544995944
,
140205544893688
,
140205544875144
]
# 查看大列表的元素id值
>>> [
id
(x)
for
x
in
person]
[
140205546176112
,
140205544996520
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205546176112
,
140205544996520
]
>>> [
id
(x)
for
x
in
cl]
[
140205546176112
,
140205544571320
]
# 查看小列表的元素id值
>>> [
id
(x)
for
x
in
person[
1
]]
[
140205545021232
,
32419728
]
>>> [
id
(x)
for
x
in
xpleaf[
1
]]
[
140205545021232
,
32419728
]
>>> [
id
(x)
for
x
in
cl[
1
]]
[
140205545021232
,
32419728
]
|
可以看到虽然是进行了深拷贝,但发现跟前面的其实并没有什么不同,下面我们再来修改其中一个小列表:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>> xpleaf[
1
][
1
]
=
22
>>> person, xpleaf, cl
([
'name'
, [
'age'
,
22
]], [
'name'
, [
'age'
,
22
]], [
'name'
, [
'age'
,
20
]])
# 查看大列表的元素id值
>>> [
id
(x)
for
x
in
person]
[
140205546176112
,
140205544996520
]
>>> [
id
(x)
for
x
in
xpleaf]
[
140205546176112
,
140205544996520
]
>>> [
id
(x)
for
x
in
cl]
[
140205546176112
,
140205544571320
]
# 查看小列表的元素id值
>>> [
id
(x)
for
x
in
person[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
xpleaf[
1
]]
[
140205545021232
,
32419680
]
>>> [
id
(x)
for
x
in
cl[
1
]]
[
140205545021232
,
32419728
]
|
此时可以看到,cl的小列表的第二个元素的id跟原来是一样的,但是xpleaf和person的小列表元素的id发生了改变,同时值也是我们修改的那样。那是因为xpleaf是person的浅拷贝,但是cl是person的深拷贝。
这就是所谓的深拷贝。
4.第四个例子:检验
其实只要理解了上面三个例子(这意味着对Python对象本身和序列类型本身也有比较深刻的理解),所以的浅拷贝和深拷贝也不是什么问题了。
至于是否明白,可以参考下面这个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> person
=
[
'name'
, (
'hobby'
, [
1
,
2
])]
>>> xpleaf
=
person[:]
>>>
from
copy
import
deepcopy as dcp
>>> cl
=
dcp(person)
>>>
>>> xpleaf[
0
]
=
'xpleaf'
>>> cl[
0
]
=
'cl'
>>> person, xpleaf, cl
([
'name'
, (
'hobby'
, [
1
,
2
])], [
'xpleaf'
, (
'hobby'
, [
1
,
2
])], [
'cl'
, (
'hobby'
, [
1
,
2
])])
>>>
>>> xpleaf[
1
][
1
][
0
]
=
'clyyh'
>>> person, xpleaf, cl
([
'name'
, (
'hobby'
, [
'clyyh'
,
2
])], [
'xpleaf'
, (
'hobby'
, [
'clyyh'
,
2
])], [
'cl'
, (
'hobby'
, [
1
,
2
])])
|
如果对这个例子的输出觉得完全没有问题的,那么也就OK了!
当然,肯定还有遗漏的地方,还望指出。