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 拷贝 深拷贝 浅拷贝 赋值的更多相关文章

  1. Python拷贝(深拷贝deepcopy与浅拷贝copy)

    Python中的对象之间赋值时是按引用传递的,如果需要拷贝对象,需要使用标准库中的copy模块. 1.copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2.copy.deepco ...

  2. python进阶----深拷贝&浅拷贝

    复制需要区分,,复制的是源文件的数据,还是指向源文件数据的地址 1.引用   b=a时,理解为b指向了a指向的数据,相当于引用复制 a=[1,2] b=a #验证复制的是数据还是地址 #1.查看ab的 ...

  3. Python 拷贝对象（深拷贝deepcopy与浅拷贝copy）

    1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 一个很好的例子: # -*-coding:utf-8 -*- ...

  4. Python里的赋值 拷贝 深拷贝

    import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象 b = a #赋值,传对象的引用 c = copy.copy(a) #对象拷贝,浅拷贝 d = copy. ...

  5. python中的浅拷贝和深拷贝

    1.赋值语句 a = 'abc' b = a print id(a) print id(b) # id(a):29283464 # id(b):29283464 通过简单的复制,我们可以看到,a b其 ...

  6. python基础知识5——赋值与深浅拷贝——整数和字符串，列表元组字典

    深浅copy 一.数字和字符串 对于 数字 和 字符串 而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址. 1 import copy 2 # ######### 数字.字符串 #### ...

  7. python中的浅拷贝与赋值不同

    Python中的对象之间赋值时是按引用传递的,如果需要拷贝对象,需要使用标准库中的copy模块. 1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deep ...

  8. python 中 深拷贝和浅拷贝的理解

    在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一 ...

  9. python中深拷贝和浅拷贝

    python中所谓浅拷贝就是对引用的拷贝,所谓深拷贝就是对对象的资源的拷贝. 首先,对赋值操作我们要有以下认识: 赋值是将一个对象的地址赋值给一个变量,让变量指向该地址( 旧瓶装旧酒 ). 修改不可变 ...

随机推荐

  1. for循环.html

    <script> for (var i = 1; i < 5 ; i++) { alert(i); } 公式需要记住,并多加练习,加深记忆,注意编写格式 for (var i = 1 ...

  2. Flume数据采集准备

    , flume的官网:http://flume.apache.org/ flume的下载地址:http://flume.apache.org/download.html 这里我们用的是apache版本 ...

  3. http与https之间的区别

    超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息,HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以直接读懂 ...

  4. 6.6安装编译安装zabbix3.2

    添加yum源 get -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo #安装阿里云y ...

  5. 《Linux性能及调优指南》第二章：监控和基准工具2.1-2.2

    翻译:飞哥 (http://hi.baidu.com/imlidapeng) 版权所有,尊重他人劳动成果,转载时请注明作者和原始出处及本声明. 原文名称:<Linux Performance a ...

  6. shell 的有用函数

    1.isNumber 2.命令可用 3.当前用户是root 1.isNumber 判断“字符串”是否是个数字: declare chkNumber= isNumber(){ parameter1=$ ...

  7. [Android]Android布局优化之<include />

    转载请标明:转载于http://www.cnblogs.com/Liuyt-61/p/6602891.html -------------------------------------------- ...

  8. NEU(Fst Network Embedding Enhancement via High Order Proximity Approximation)

    NEU(Fst Network Embedding Enhancement via High Order Proximity Approximation) NEU:通过对高阶相似性的近似,加持快速网络 ...

  9. org.springframework.web.servlet.PageNotFound - No mapping found for HTTP request with URI

    在重启项目中会遇到[org.springframework.web.servlet.PageNotFound] - No mapping found for HTTP request with URI ...

  10. python中str的索引、切片

    1 a = "hello" 2 a1 = a[1] 3 a2 = a[0:2] 4 print(a1) 5 print(a2) 我们通过索引获取字符串中指定位数的字符 通过切片获取 ...