Python深浅拷贝

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（外层是可变类型，内层是不可变类型）深拷贝：内层地址相同')