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

运行结果：

总结：
特殊情况2：外层是可变类型，内层是不可变类型
浅拷贝：外层对象被拷贝，内层对象还是原来对象的引用（外层地址改变，内层地址不变）。
深拷贝：外层对象和内层对象都被拷贝，都开辟了新的内存地址（外层地址和内层地址都改变）。
类似于可变类型的深浅拷贝。

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

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

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

我这么可爱，还等什么？快点关注我哦~