python 拷贝 深拷贝 浅拷贝 赋值
t = [1,["a","b"]]
t_bak = t
t_cop = copy.copy(t)
t_deep = copy.deepcopy(t)
print("id(t)--- "+str(id(t))+" id(t[1]) " +str(id(t[1])) +" id(t[1][1] 也就是 内部列表中的第二个元素"+str(id(t[1][1])))
print("id(t_bak)--- "+str(id(t_bak))+" id(t_bak[1]) " +str(id(t_bak[1])) +" id(t_bak[1][1] 也就是 内部列表中的第二个元素"+str(id(t_bak[1][1])))
print("id(t_copy)--- "+str(id(t_cop))+" id(t_cop[1]) " +str(id(t_cop[1])) +" id(t_cop[1][1] 也就是 内部列表中的第二个元素"+str(id(t_cop[1][1])))
print("id(t_deep)--- "+str(id(t_deep))+" id(t_deep[1]) " +str(id(t_deep[1])) +" id(t_deep[1][1] 也就是 内部列表中的第二个元素"+str(id(t_deep[1][1])))
id(t)--- 140706556438648 id(t[1]) 140706556410336 id(t[1][1] 也就是 内部列表中的第二个元素140706557474336
id(t_bak)--- 140706556438648 id(t_bak[1]) 140706556410336 id(t_bak[1][1] 也就是 内部列表中的第二个元素140706557474336
id(t_copy)--- 140706534860560 id(t_cop[1]) 140706556410336 id(t_cop[1][1] 也就是 内部列表中的第二个元素140706557474336
id(t_deep)--- 140706556438576 id(t_deep[1]) 140706556439656 id(t_deep[1][1] 也就是 内部列表中的第二个元素140706557474336
可以看到， t 和t_bak 这种直接赋值的操作，其实指向的是同一个对象,无论是第一层，还是内部嵌套的元素
而 t 和 t_cop 这种copy操作，第一层的id已经不一样了，说明他们创建了新的对象，但是内部嵌套的元素还是一致的，说明给他们内部嵌套指向的是同一个对象。
再说 t 和t_deep 这种deepcopy 深拷贝操作，发现，第一层已经不一样了，说明创建了新的对象，但是内部嵌套的元素还是一样的
修改t_bak(1)
t_bak.append("3")
print(t) #[1, ['a', 'b'], '3']
print(t_bak)#[1, ['a', 'b'], '3']
print(t_cop)#[1, ['a', 'b']]
print(t_deep)#[1, ['a', 'b']]
print("id(t)--- "+str(id(t))+" id(t[1]) " +str(id(t[1])) +" id(t[1][1] 也就是 内部列表中的第二个元素"+str(id(t[1][1])))
print("id(t_bak)--- "+str(id(t_bak))+" id(t_bak[1]) " +str(id(t_bak[1])) +" id(t_bak[1][1] 也就是 内部列表中的第二个元素"+str(id(t_bak[1][1])))
print("id(t_copy)--- "+str(id(t_cop))+" id(t_cop[1]) " +str(id(t_cop[1])) +" id(t_cop[1][1] 也就是 内部列表中的第二个元素"+str(id(t_cop[1][1])))
print("id(t_deep)--- "+str(id(t_deep))+" id(t_deep[1]) " +str(id(t_deep[1])) +" id(t_deep[1][1] 也就是 内部列表中的第二个元素"+str(id(t_deep[1][1])))
id(t)--- 139789718802088 id(t[1]) 139789718801728 id(t[1][1] 也就是 内部列表中的第二个元素139789719836192
id(t_bak)--- 139789718802088 id(t_bak[1]) 139789718801728 id(t_bak[1][1] 也就是 内部列表中的第二个元素139789719836192
id(t_copy)--- 139789697222416 id(t_cop[1]) 139789718801728 id(t_cop[1][1] 也就是 内部列表中的第二个元素139789719836192
id(t_deep)--- 139789718802232 id(t_deep[1]) 139789718802376 id(t_deep[1][1] 也就是 内部列表中的第二个元素139789719836192
修改 t_bak(2)
t_bak[1][1]='c'
print(t) #[1, ['a', 'c'],]
print(t_bak)#[1, ['a', 'c']]
print(t_cop)#[1, ['a', 'c']]
print(t_deep)#[1, ['a', 'b']]
id(t)--- 140085180813112 id(t[1]) 140085180812968 id(t[1][1] 也就是 内部列表中的第二个元素140085181848632
id(t_bak)--- 140085180813112 id(t_bak[1]) 140085180812968 id(t_bak[1][1] 也就是 内部列表中的第二个元素140085181848632
id(t_copy)--- 140085159233296 id(t_cop[1]) 140085180812968 id(t_cop[1][1] 也就是 内部列表中的第二个元素140085181848632
id(t_deep)--- 140085180813040 id(t_deep[1]) 140085180812536 id(t_deep[1][1] 也就是 内部列表中的第二个元素140085181847072
这也证明了上述：
浅拷贝创建了一个新的对象，但是内部嵌套的元素仍然和原对象引用的是同一个。
深拷贝，无论内外都重新复制了一份
修改 t_cop
t_cop.append(4)
t_cop[1][1] = 'd'
print(t) #[1, ['a', 'd']]
print(t_bak)##[1, ['a', 'd']]
print(t_cop)#[1, ['a', 'd'], 4]
print(t_deep)#[1, ['a', 'b']]
print("id(t)--- "+str(id(t))+" id(t[1]) " +str(id(t[1])) +" id(t[1][1] 也就是 内部列表中的第二个元素"+str(id(t[1][1])))
print("id(t_bak)--- "+str(id(t_bak))+" id(t_bak[1]) " +str(id(t_bak[1])) +" id(t_bak[1][1] 也就是 内部列表中的第二个元素"+str(id(t_bak[1][1])))
print("id(t_copy)--- "+str(id(t_cop))+" id(t_cop[1]) " +str(id(t_cop[1])) +" id(t_cop[1][1] 也就是 内部列表中的第二个元素"+str(id(t_cop[1][1])))
print("id(t_deep)--- "+str(id(t_deep))+" id(t_deep[1]) " +str(id(t_deep[1])) +" id(t_deep[1][1] 也就是 内部列表中的第二个元素"+str(id(t_deep[1][1])))
id(t)--- 140596834620840 id(t[1]) 140596834621920 id(t[1][1] 也就是 内部列表中的第二个元素140596835776312
id(t_bak)--- 140596834620840 id(t_bak[1]) 140596834621920 id(t_bak[1][1] 也就是 内部列表中的第二个元素140596835776312
id(t_copy)--- 140596813072144 id(t_cop[1]) 140596834621920 id(t_cop[1][1] 也就是 内部列表中的第二个元素140596835776312
id(t_deep)--- 140596834620912 id(t_deep[1]) 140596834651312 id(t_deep[1][1] 也就是 内部列表中的第二个元素140596835685920
修改 t_deep
t_deep.append(5)
t_deep[1][1] = 'e'
print(t) #[1, ['a', 'b']]
print(t_bak)#[1, ['a', 'b']]
print(t_cop)#[1, ['a', 'b']]
print(t_deep)#[1, ['a', 'e'], 5]
print("id(t)--- "+str(id(t))+" id(t[1]) " +str(id(t[1])) +" id(t[1][1] 也就是 内部列表中的第二个元素"+str(id(t[1][1])))
print("id(t_bak)--- "+str(id(t_bak))+" id(t_bak[1]) " +str(id(t_bak[1])) +" id(t_bak[1][1] 也就是 内部列表中的第二个元素"+str(id(t_bak[1][1])))
print("id(t_copy)--- "+str(id(t_cop))+" id(t_cop[1]) " +str(id(t_cop[1])) +" id(t_cop[1][1] 也就是 内部列表中的第二个元素"+str(id(t_cop[1][1])))
print("id(t_deep)--- "+str(id(t_deep))+" id(t_deep[1]) " +str(id(t_deep[1])) +" id(t_deep[1][1] 也就是 内部列表中的第二个元素"+str(id(t_deep[1][1])))
id(t)--- 140579373325560 id(t[1]) 140579373295088 id(t[1][1] 也就是 内部列表中的第二个元素140579374360096
id(t_bak)--- 140579373325560 id(t_bak[1]) 140579373295088 id(t_bak[1][1] 也就是 内部列表中的第二个元素140579374360096
id(t_copy)--- 140579351746320 id(t_cop[1]) 140579373295088 id(t_cop[1][1] 也就是 内部列表中的第二个元素140579374360096
id(t_deep)--- 140579373325488 id(t_deep[1]) 140579373326136 id(t_deep[1][1] 也就是 内部列表中的第二个元素140579374451928
python 拷贝 深拷贝 浅拷贝 赋值的更多相关文章
- Python拷贝(深拷贝deepcopy与浅拷贝copy)
Python中的对象之间赋值时是按引用传递的,如果需要拷贝对象,需要使用标准库中的copy模块. 1.copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2.copy.deepco ...
- python进阶----深拷贝&浅拷贝
复制需要区分,,复制的是源文件的数据,还是指向源文件数据的地址 1.引用 b=a时,理解为b指向了a指向的数据,相当于引用复制 a=[1,2] b=a #验证复制的是数据还是地址 #1.查看ab的 ...
- Python 拷贝对象（深拷贝deepcopy与浅拷贝copy）
1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 一个很好的例子: # -*-coding:utf-8 -*- ...
- Python里的赋值 拷贝 深拷贝
import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象 b = a #赋值,传对象的引用 c = copy.copy(a) #对象拷贝,浅拷贝 d = copy. ...
- python中的浅拷贝和深拷贝
1.赋值语句 a = 'abc' b = a print id(a) print id(b) # id(a):29283464 # id(b):29283464 通过简单的复制,我们可以看到,a b其 ...
- python基础知识5——赋值与深浅拷贝——整数和字符串，列表元组字典
深浅copy 一.数字和字符串 对于 数字 和 字符串 而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址. 1 import copy 2 # ######### 数字.字符串 #### ...
- python中的浅拷贝与赋值不同
Python中的对象之间赋值时是按引用传递的,如果需要拷贝对象,需要使用标准库中的copy模块. 1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deep ...
- python 中 深拷贝和浅拷贝的理解
在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一 ...
- python中深拷贝和浅拷贝
python中所谓浅拷贝就是对引用的拷贝,所谓深拷贝就是对对象的资源的拷贝. 首先,对赋值操作我们要有以下认识: 赋值是将一个对象的地址赋值给一个变量,让变量指向该地址( 旧瓶装旧酒 ). 修改不可变 ...
随机推荐
- 腾讯微信被怼，iOS版微信不能打赏了
2017年4月19日,估计很多有着大量粉丝的微信自媒体作者会感到很不爽,因为他们的苹果粉丝再也无法很爽快地.肆意.任性地打赏他们了,按目前iphone手机的占有率,估计打赏率会掉一半以上. 据微信派微 ...
- Android---页面跳转
1.首先在一个布局文件(.XML)中绘画了一个跳转按钮(id为btn1): <Button android:id="@+id/btn1" an ...
- Android获取文件夹下的所有子文件名称；
public static List<String> getFilesAllName(String path) { File file=new File(path); File[] fil ...
- JavaScript之函数，词法分析，内置对象和方法
函数 函数定义 JavaScript中的函数和Python中的非常类似,只是定义方式有点区别. // 普通函数定义 function f1() { console.log("Hello wo ...
- Linux之文档与目录结构 (/ 用法, 相对路径,绝对路径)
Linux之文档与目录结构 Linux文件系统结构 Linux目录结构的组织形式和Windows有很大的不同.首先Linux没有“盘(C盘.D盘.E盘)”的概念.已经建立文件系统的硬盘分区被挂载到 ...
- 微信小程序开发warning： Now you can provide attr "wx:key" for a "wx:for" to improve performance
用微信官方的模板发现突然报了这个warning,检查原因: 官方解释: wx:key 如果列表中项目的位置会动态改变或者有新的项目添加到列表中,并且希望列表中的项目保持自己的特征和状态(如 <i ...
- 2014年第五届蓝桥杯JavaB组省赛试题解析
题目及解析如下: 题目大致介绍: 第一题到第三题以及第六题是结果填空,方法不限只要得到最后结果就行 第四题和第五题是代码填空题,主要考察算法基本功和编程基本功 第七题到第十题是编程题,要求编程解决问题 ...
- Ajax总结一下
一.什么是Ajax Ajax(Asynchronous JavaScript and XML),可以理解为JavaScript执行异步网络请求.通俗的理解的话就是,如果没有Ajax技术,改变网页的一小 ...
- ubuntu 16042 安装过程
IDE接口的硬盘被称为hd SCSI和SATA接口的硬盘则被称为sd 第1块硬盘称为sda, 第2块硬盘称为sdb 一块硬盘最多有4个主分区,主分区以外的分区称为扩展分区,硬盘可以没有扩展分区,但是一 ...
- [Android]Android布局优化之 ViewStub
转载请标注:转载于http://www.cnblogs.com/Liuyt-61/p/6602926.html -------------------------------------------- ...