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,如需转载请自行联系原作者
相关文章
|
机器学习/深度学习 数据采集 算法
Python编程语言进阶学习:深入探索与高级应用
【7月更文挑战第23天】Python的进阶学习是一个不断探索和实践的过程。通过深入学习高级数据结构、面向对象编程、并发编程、性能优化以及在实际项目中的应用,你将能够更加熟练地运用Python解决复杂问题,并在编程道路上走得更远。记住,理论知识只是基础,真正的成长来自于不断的实践和反思。
|
数据采集 Java C语言
Python面向对象的高级动态可解释型脚本语言简介
Python是一种面向对象的高级动态可解释型脚本语言。
153 3
|
机器学习/深度学习 数据采集 人工智能
Python 是一种广泛使用的高级编程语言
【7月更文挑战第17天】Python 是一种广泛使用的高级编程语言
168 2
|
存储 算法 Python
“解锁Python高级数据结构新姿势:图的表示与遍历,让你的算法思维跃升新高度
【7月更文挑战第13天】Python中的图数据结构用于表示复杂关系,通过节点和边连接。常见的表示方法是邻接矩阵(适合稠密图)和邻接表(适合稀疏图)。图遍历包括DFS(深度优先搜索)和BFS(广度优先搜索):DFS深入探索分支,BFS逐层访问邻居。掌握这些技巧对优化算法和解决实际问题至关重要。**
148 1
|
API Python
python中copy模块的使用,深拷贝和浅拷贝
python中copy模块的使用,深拷贝和浅拷贝
252 0
|
存储 算法 调度
惊呆了!Python高级数据结构堆与优先队列,竟然能这样优化你的程序性能!
【7月更文挑战第10天】Python的heapq模块实现了堆和优先队列,提供heappush和heappop等函数,支持O(log n)时间复杂度的操作。优先队列常用于任务调度和图算法,优化性能。例如,Dijkstra算法利用最小堆加速路径查找。堆通过列表存储,内存效率高。示例展示了添加、弹出和自定义优先级元素。使用堆优化程序,提升效率。
163 2
|
算法 调度 Python
Python高手必备!堆与优先队列的高级应用,掌握它们,技术路上畅通无阻!
【7月更文挑战第9天】Python的heapq模块实现了堆数据结构,提供O(log n)操作如`heappush`和`heappop`。堆是完全二叉树,用于优先队列,保证最大/最小元素快速访问。例如,最小堆弹出最小元素,常用于Dijkstra算法找最短路径、Huffman编码压缩数据及任务调度。通过`heappush`和`heappop`可创建和管理优先队列,如`(优先级, 数据)`元组形式。理解并运用这些概念能优化算法效率,解决复杂问题。
142 2
|
消息中间件 网络协议 网络安全
解锁Python Socket新姿势,进阶篇带你玩转高级网络通信技巧!
【7月更文挑战第26天】掌握Python Socket后,探索网络通信高级技巧。本指南深化Socket编程理解,包括非阻塞I/O以提升并发性能(示例使用`select`),SSL/TLS加密确保数据安全,以及介绍高级网络协议库如HTTP、WebSocket和ZeroMQ,简化复杂应用开发。持续学习,成为网络通信专家!
111 0
|
存储 数据处理 开发者
告别繁琐查找!Python高级数据结构Trie树与Suffix Tree,让数据处理更轻松!
【7月更文挑战第19天】Python的Trie树优化字符串搜索,利用前缀减少无效操作,提升效率;Suffix Tree则高效处理后缀问题,尤其适用于文本搜索与生物信息学。虽构建复杂,但能加速后缀查询。掌握这两种数据结构,能有效应对大规模数据挑战,简化处理流程,提升开发效率。
259 0
|
数据采集 数据挖掘 数据处理
Python数据分析加速器:深度挖掘Pandas与NumPy的高级功能
【7月更文挑战第14天】Python的Pandas和NumPy库是数据分析的核心工具。Pandas以其高效的数据处理能力,如分组操作和自定义函数应用,简化了数据清洗和转换。NumPy则以其多维数组和广播机制实现快速数值计算。两者协同工作,如在DataFrame与NumPy数组间转换进行预处理,提升了数据分析的效率和精度。掌握这两者的高级功能是提升数据科学技能的关键。**
171 0

热门文章

最新文章

推荐镜像

更多