Python高级:细说Python浅拷贝和深拷贝

简介:

    先看看浅拷贝的概念:

  • 浅拷贝:对一个对象进行浅拷贝其实是新创建了一个类型跟原对象一样,其内容还是原来对象元素的引用,换句话说,这个拷贝的对象本身是新的,但是它的内容不是

        序列类型对象的浅拷贝是默认类型拷贝,有以下几种实现方式:

  • 完全切片操作:下面操作会有

  • 利用工厂函数:比如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  in  person, xpleaf, cl]    #虽然是浅拷贝,但是其实也是生成了新的对象
[ 140205544875144 140205544893688 140205544996232 ]
>>> [ id (x)  for  in  person]
[ 140205545021232 32419728 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205545021232 32419728 ]
>>> [ id (x)  for  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  in  person]
[ 140205545021232 32419728 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  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  in  person, xpleaf, cl]
[ 140205544995944 140205544893688 140205544875144 ]
# 查看大列表的元素id值
>>> [ id (x)  for  in  person, xpleaf, cl]
[ 140205544996160 140205544875144 140205544996520 ]
>>> [ id (x)  for  in  person]
[ 140205546176112 140205544995944 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205546176112 140205544995944 ]
>>> [ id (x)  for  in  cl]
[ 140205546176112 140205544995944 ]
# 查看小列表的元素id值
>>> [ id (x)  for  in  person[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  in  xpleaf[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  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  in  person, xpleaf, cl]
[ 140205544995944 140205544893688 140205544875144 ]
# 查看大列表的元素id值
>>> [ id (x)  for  in  person]
[ 140205546176112 140205544995944 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205546176112 140205544995944 ]
>>> [ id (x)  for  in  cl]
[ 140205546176112 140205544995944 ]
# 查看小列表的元素id值
>>> [ id (x)  for  in  person[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  in  xpleaf[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  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  in  person, xpleaf, cl]
[ 140205544995944 140205544893688 140205544875144 ]
# 查看大列表的元素id值
>>> [ id (x)  for  in  person]
[ 140205546176112 140205544996520 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205546176112 140205544996520 ]
>>> [ id (x)  for  in  cl]
[ 140205546176112 140205544571320 ]
# 查看小列表的元素id值
>>> [ id (x)  for  in  person[ 1 ]]
[ 140205545021232 32419728 ]
>>> [ id (x)  for  in  xpleaf[ 1 ]]
[ 140205545021232 32419728 ]
>>> [ id (x)  for  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  in  person]
[ 140205546176112 140205544996520 ]
>>> [ id (x)  for  in  xpleaf]
[ 140205546176112 140205544996520 ]
>>> [ id (x)  for  in  cl]
[ 140205546176112 140205544571320 ]
# 查看小列表的元素id值
>>> [ id (x)  for  in  person[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  in  xpleaf[ 1 ]]
[ 140205545021232 32419680 ]
>>> [ id (x)  for  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了!



        当然,肯定还有遗漏的地方,还望指出。




本文转自 xpleaf 51CTO博客,原文链接:http://blog.51cto.com/xpleaf/1753313,如需转载请自行联系原作者
相关文章
|
21天前
|
运维 Python
【Python】python深拷贝与浅拷贝详解(必须掌握)
【Python】python深拷贝与浅拷贝详解(必须掌握)
|
10天前
|
JavaScript 前端开发 Python
Python 高级主题: 解释 Python 中的闭包是什么?
【4月更文挑战第13天】闭包是内部函数引用外部变量的函数对象,作为外部函数的返回值。当外部函数执行完毕,其变量本应消失,但由于内部函数的引用,这些变量在内存中保持存活,形成闭包。例如,在外函数中定义内函数并返回内函数引用,实现对外部局部变量的持久访问。闭包在Python和JavaScript等语言中常见,是强大的编程工具,连接不同作用域并允许局部变量持久化,用于复杂程序设计。**
16 4
|
1月前
|
监控 API C语言
【Python 基础教程 22】全面揭秘Python3 os模块:从入门到高级的实用教程指南
【Python 基础教程 22】全面揭秘Python3 os模块:从入门到高级的实用教程指南
62 1
|
1月前
|
编译器 测试技术 C++
【Python 基础教程 02】 数据类型全解析:从基础到高级,实用指南及详细使用案例
【Python 基础教程 02】 数据类型全解析:从基础到高级,实用指南及详细使用案例
182 0
|
1月前
|
Python
请简述Python中的深拷贝和浅拷贝的区别?并举例说明。
【2月更文挑战第25天】【2月更文挑战第84篇】请简述Python中的深拷贝和浅拷贝的区别?并举例说明。
|
1月前
|
JSON 前端开发 API
Python中的JSON模块:从基础到高级应用全解析
【2月更文挑战第3天】 Python中的JSON模块:从基础到高级应用全解析
81 6
|
1月前
|
安全 Python
Python中的深拷贝和浅拷贝的区别
Python中的深拷贝和浅拷贝的区别
15 0
|
1月前
|
Python
Python的高级语法及许多特性
Python的高级语法及许多特性
20 0
|
1月前
|
Python
|
1月前
|
数据采集 机器学习/深度学习 算法
Python中的CatBoost高级教程——时间序列数据建模
Python中的CatBoost高级教程——时间序列数据建模【2月更文挑战第14天】
56 1
Python中的CatBoost高级教程——时间序列数据建模