当前位置: 首页> 房产> 家装 > Python深浅拷贝

Python深浅拷贝

时间:2025/7/9 7:41:54来源:https://blog.csdn.net/KongMingJue/article/details/141688985 浏览次数:0次

0、前置知识

数据类型:可变类型、不可变类型

不可变类型:一旦创建就不可修改的对象,包括字符串、元组、数值类型(整型、浮点型)

该对象所指向的内存中的值不能被改变。

当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。

可变类型:可以修改的对象,包括列表、字典、集合

该对象所指向的内存中的值可以被改变。

变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的地址,通俗点说就是原地改变。

一、可变类型:深浅拷贝

1.1 可变类型,浅拷贝

可变类型 浅拷贝:只拷贝外层对象,内层对象还是原内容的引用!

# 浅拷贝:只拷贝外层对象,内层对象还是原内容的引用!import copy
# 1. 定义一个嵌套列表
list1 = [1,2,3,[4,5]]# 2. 浅拷贝 => 切片也是浅拷贝的一种
list2 = copy.copy(list1)
print(id(list1), '可变类型浅拷贝:外层地址不同')
print(id(list2), '可变类型浅拷贝:外层地址不同')
print(id(list1[3]), '可变类型浅拷贝:内层地址相同')
print(id(list2[3]), '可变类型浅拷贝:内层地址相同')# 3. 浅拷贝带来的影响:如果内层对象发生改变,则两个对象都会受到影响
list2[3][0] = 8
print(list1)
print(list2)

运行结果如下:
在这里插入图片描述

1.2 可变类型,深拷贝

可变类型 深拷贝:创建一个新对象,新对象与原对象完全不同,修改新对象不会影响原对象。
不仅拷贝了外层对象,也拷贝内层对象。

# 1.导包
import copy
# 2.定义一个列表嵌套
list1 = [1,2,3,[4,5]]
list2 = copy.deepcopy(list1)# 3.外层对象已被拷贝
print(id(list1), '可变类型深拷贝:外层地址不同')
print(id(list2), '可变类型深拷贝:外层地址不同')# 4.内层对象也被拷贝
print(id(list1[3]), '可变类型深拷贝:内层地址不同')
print(id(list2[3]), '可变类型深拷贝:内层地址不同')# 5.修改新对象
list2[3][0] = 6
print(list1)
print(list2)

运行结果如下:
在这里插入图片描述
总结:
可变类型拷贝时:
浅拷贝:外层对象被拷贝,内层对象还是原来对象的引用(外层地址改变,内层地址不变)。
深拷贝:外层对象和内层对象都被拷贝,都开辟了新的内存地址(外层地址和内层地址都改变)。

二、不可变类型:深浅拷贝

2.1 不可变类型,浅拷贝

不可变类型 浅拷贝:不会开辟新内存空间,新对象拷贝内容相当于原内容的引用。

import copy
# 1. 定义一个元组嵌套结构
tuple1 = (1, 2, 3, (4, 5))
# 2. 浅拷贝
tuple2 = copy.copy(tuple1)print(id(tuple1), '不可变类型浅拷贝:外层地址相同')
print(id(tuple2), '不可变类型浅拷贝:外层地址相同')print(id(tuple1[3]), '不可变类型浅拷贝:内层地址相同')
print(id(tuple2[3]), '不可变类型浅拷贝:内层地址相同')

运行结果如下:
在这里插入图片描述

2.1 不可变类型,深拷贝

不会开辟新内存空间,新对象拷贝内容相当于原内容的引用。

import copy
# 1. 定义一个元组嵌套结构
tuple1 = (1, 2, 3, (4, 5))
# 2. 深拷贝
tuple2 = copy.deepcopy(tuple1)print(id(tuple1), '不可变类型深拷贝:外层地址相同')
print(id(tuple2), '不可变类型深拷贝:外层地址相同')print(id(tuple1[3]), '不可变类型深拷贝:内层地址相同')
print(id(tuple2[3]), '不可变类型深拷贝:内层地址相同')

运行结果如下:
在这里插入图片描述

总结:
不可变类型拷贝时:
无论是深拷贝还是浅拷贝,都不会开辟新的内存空间,新拷贝的对象(无论是外层对象还是内层对象)都引用了原来对象的地址,内外层地址都不发生改变!

以上两大种情况,内外层对象的类型都保持一致,意思就是:
1.1和1.2 :外层对象是可变类型,内层对象也是可变类型(例子中内、外层对象都是列表类型)
2.1和2.2:外层对象是不可变类型,内层对象也是不可变类型(例子中内、外层对象都是元组类型)
那么,下面来为你介绍特殊情况,就是外层对象和内层对象的类型不一致的情况

三、特殊情况

3.1 特殊情况1:外层是不可变类型,内层是可变类型

3.1.1 特殊情况1:外层不可变类型,内层可变类型 浅拷贝

外层是不可变,内层是可变类型
浅拷贝:不会开辟新内存空间,新对象只是复制原内容引用。外层对象和内层对象地址相同。

import copy
# 外层是元组,不可变类型
# 内层是列表,可变类型
tuple1 = (1,2,3,[4,5])# 特殊情况1:(外层不可变类型,内层可变类型)浅拷贝
tuple2 = copy.copy(tuple1)
print(id(tuple1), '特殊情况1(外层不可变类型,内层可变类型)浅拷贝:外层地址相同')
print(id(tuple2), '特殊情况1(外层不可变类型,内层可变类型)浅拷贝:外层地址相同')
print(id(tuple1[3]), '特殊情况1(外层不可变类型,内层可变类型)浅拷贝:内层地址相同')
print(id(tuple2[3]), '特殊情况1(外层不可变类型,内层可变类型)浅拷贝:内层地址相同')

运行结果:
![

3.1.2 特殊情况1:外层不可变类型,内层可变类型 深拷贝

外层是不可变,内层是可变类型
深拷贝:创建一个新对象,新对象与原对象完全独立。外层对象和内层对象都不同。

import copy
# 外层是元组,不可变类型
# 内层是列表,可变类型
tuple1 = (1,2,3,[4,5])# 特殊情况1:(外层不可变类型,内层可变类型)深拷贝
tuple2 = copy.deepcopy(tuple1)
print(id(tuple1), '特殊情况1(外层不可变类型,内层可变类型)深拷贝:外层地址不同')
print(id(tuple2), '特殊情况1(外层不可变类型,内层可变类型)深拷贝:外层地址不同')
print(id(tuple1[3]), '特殊情况1(外层不可变类型,内层可变类型)深拷贝:内层地址不同')
print(id(tuple2[3]), '特殊情况1(外层不可变类型,内层可变类型)深拷贝:内层地址不同')

运行结果:
在这里插入图片描述
小结:
外层是不可变类型,内层是可变类型
浅拷贝:不会开辟新内存空间,新对象只是复制原内容引用。内外层地址都相同。
深拷贝:创建一个新对象,新对象与原对象完全独立。内外层地址都不同。

3.2 特殊情况2: 外层是可变类型,内层是不可变类型

3.2.1 特殊情况2:外层是可变类型,内层是不可变类型 浅拷贝

import copy# 外层是列表,可变类型
# 内层是元组,不可变类型
list1 = [1, 2, 3, (4, 5)]# 特殊情况2:(外层是可变类型,内层是不可变类型)浅拷贝
list2 = copy.copy(list1)
print(id(list1), '特殊情况2(外层是可变类型,内层是不可变类型)浅拷贝:外层地址不同')
print(id(list2), '特殊情况2(外层是可变类型,内层是不可变类型)浅拷贝:外层地址不同')
print(id(list1[3]), '特殊情况2(外层是可变类型,内层是不可变类型)浅拷贝:内层地址相同')
print(id(list2[3]), '特殊情况2(外层是可变类型,内层是不可变类型)浅拷贝:内层地址相同')

运行结果:
在这里插入图片描述

3.2.2 特殊情况2:外层是可变类型,内层是不可变类型 深拷贝

import copy# 外层是列表,可变类型
# 内层是元组,不可变类型
list1 = [1, 2, 3, (4, 5)]# 特殊情况2:(外层是可变类型,内层是不可变类型)浅拷贝
list2 = copy.deepcopy(list1)
print(id(list1), '特殊情况2(外层是可变类型,内层是不可变类型)深拷贝:外层地址不同')
print(id(list2), '特殊情况2(外层是可变类型,内层是不可变类型)深拷贝:外层地址不同')
print(id(list1[3]), '特殊情况2(外层是可变类型,内层是不可变类型)深拷贝:内层地址相同')
print(id(list2[3]), '特殊情况2(外层是可变类型,内层是不可变类型)深拷贝:内层地址相同')

运行结果:
在这里插入图片描述
总结:
特殊情况2:外层是可变类型,内层是不可变类型
浅拷贝:外层对象被拷贝,内层对象还是原来对象的引用(外层地址改变,内层地址不变)。
深拷贝:外层对象和内层对象都被拷贝,都开辟了新的内存地址(外层地址和内层地址都改变)。
类似于可变类型的深浅拷贝。

============================

日拱一卒,功不唐捐,信奉长期主义

每天进步一点点,为中国人工智能的发展贡献力量!

我这么可爱,还等什么?快点关注我哦~

关键字:Python深浅拷贝

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: