直接赋值、浅拷贝、深拷贝

在 Python 中，一切皆对象，变量本质上保存的是对象的引用。因此在理解复制行为时，需要区分“对象本身”和“对象引用”。

直接赋值

两个变量指向同一个对象，修改其中一个变量的值会影响另一个变量的值。

6
1
nums1 = [10, 20, 30, 40]
2
nums2 = nums1
3
print(f"nums1的地址为：{id(nums1)}")  # nums1的地址为：4300438912
4
print(f"nums2的地址为：{id(nums2)}")  # nums2的地址为：4300438912
5
print(f"nums1里的元素为：{nums1}")  # nums1里的元素为：[10, 20, 30, 40]
6
print(f"nums2里的元素为：{nums2}")  # nums2里的元素为：[10, 20, 30, 40]

在内存中的逻辑图示：

修改其中一个变量的值：

6
1
# 修改nums2[3] = 99
2
nums2[3] = 99
3
print(f"修改之后的nums1的地址为：{id(nums1)}")  # nums1的地址为：4300438912
4
print(f"修改之后的nums2的地址为：{id(nums2)}")  # nums2的地址为：4300438912
5
print(f"修改之后的nums1里的元素为：{nums1}")  # 修改之后的nums1里的元素为：[10, 20, 30, 99]
6
print(f"修改之后的nums2里的元素为：{nums2}")  # 修改之后的nums2里的元素为：[10, 20, 30, 99]

修改之后的内存中的逻辑图示：

这里我们需要注意的是，虽然我们修改了nums2的值，但是nums1的值也被修改了。这是因为变量nums1和变量nums2指向同一个实例对象（可变对象），因此它们看到的列表内容也是一样的。但是，list 里的元素是 int 类型（不可变对象）。当我们执行 nums2[3] = 99 时，并不会创建新的 list，而是把 list 中第 3 个位置原本指向 40 的引用，替换为指向 99。由于 nums1 和 nums2 指向的是同一个 list 对象，所以通过 nums2 修改 list 后，nums1 看到的内容也会发生变化。 另外需要注意，因为 list 是可变类型，所以在对 list 进行元素修改时，通常不会创建新的 list 对象，而是直接在原来的 list 对象上进行修改。（这里只是简单说明可变类型和不可变类型的区别）

浅拷贝

浅拷贝是创建一个新的对象，但它包含的元素仍然是对原始对象中元素的引用。如果元素是可变对象，修改其中一个对象内部的元素，可能会影响另一个对象。

65
1
import copy
2
def show_list(list_name, list_demo, tab_count=0):
3
    print("\t" * tab_count, f"{list_name}={list_demo}")
4
    print("\t" * tab_count, f"{list_name} 的id是：{id(list_demo)}")
5
    print("\t" * tab_count, f"{list_name} 的各个元素的id是：")
6
    for index, element in enumerate(list_demo):
7
        # print("\t" * tab_count,f"{element} = {id(element)}")
8
        if isinstance(element, list):
9
            show_list(f"{list_name}[{index}]", element, tab_count + 1)
10
        else:
11
            print("\t" * (tab_count + 1), f"{element} = {id(element)}")
12

13
nums1 = [10, 20, 30, 40]
14
nums2 = copy.copy(nums1)
15
# 打印列表元素、列表地址、及其元素地址
16
show_list("nums1", nums1)
17
print()
18
show_list("nums2", nums2)
19
print()
20

21
"""
22
运行结果：
23
 nums1=[10, 20, 30, 40]
24
 nums1 的id是：4333258752
25
 nums1 的各个元素的id是：
26
         10 = 4346438080
27
         20 = 4346438400
28
         30 = 4346438720
29
         40 = 4346439040
30

31
 nums2=[10, 20, 30, 40]
32
 nums2 的id是：4333419904
33
 nums2 的各个元素的id是：
34
         10 = 4346438080
35
         20 = 4346438400
36
         30 = 4346438720
37
         40 = 4346439040
38
"""
39
# 修改nums2[3] = 99
40
nums2[3] = 99
41
print(f"{"*" * 10}修改nums2后{"*" * 10}\n")
42
# 打印列表元素、列表地址、及其元素地址
43
show_list("nums1", nums1)
44
print()
45
show_list("nums2", nums2)
46
print()
47
"""
48
运行结果：
49
**********修改nums2后**********
50
 nums1=[10, 20, 30, 40]
51
 nums1 的id是：4333258752
52
 nums1 的各个元素的id是：
53
         10 = 4346438080
54
         20 = 4346438400
55
         30 = 4346438720
56
         40 = 4346439040
57

58
 nums2=[10, 20, 30, 99]
59
 nums2 的id是：4333419904
60
 nums2 的各个元素的id是：
61
         10 = 4346438080
62
         20 = 4346438400
63
         30 = 4346438720
64
         99 = 4346440928
65
"""

在内存中的逻辑图示：

修改之后的内存中的逻辑图示：

我们可以看出，虽然 nums1 和 nums2 是两个不同的列表对象（通过浅拷贝，它们的地址不同），但是它们里面的元素是相同的（它们的元素地址相同）。当我们修改 nums2[3] 的值时，实际上是修改了 nums2 列表中的一个元素，而这个元素在内存中是一个不可变对象（整数），所以会创建一个新的整数对象 99，并将 nums2[3] 的引用指向这个新的对象。由于 nums1[3] 仍然指向原来的整数对象 40，所以 nums1 中的元素没有发生变化。

那我们就能引发一个问题：上面我们想修改nums2[3]元素的值，我们发现它是int类型的数据，是不可变的，才有了上面的效果，那么如果 nums1 和 nums2 中的元素是可变对象（比如列表），那么修改其中一个对象的元素会不会影响另一个对象呢？

这就引出了深拷贝的概念。

深拷贝

深拷贝会创建一个 新的对象，并且 递归复制原对象中的所有子对象。

84
1
import copy
2
# 定义函数
3
def show_list(list_name, list_demo, tab_count=0):
4
    print("\t" * tab_count, f"{list_name}={list_demo}")
5
    print("\t" * tab_count, f"{list_name} 的id是：{id(list_demo)}")
6
    print("\t" * tab_count, f"{list_name} 的各个元素的id是：")
7
    for index, element in enumerate(list_demo):
8
        # print("\t" * tab_count,f"{element} = {id(element)}")
9
        if isinstance(element, list):
10
            show_list(f"{list_name}[{index}]", element, tab_count + 1)
11
        else:
12
            print("\t" * (tab_count + 1), f"{element} = {id(element)}")
13

14
# 定义列表
15
nums1 = [10, 20, 30, [40, 50]]
16
nums2 = copy.deepcopy(nums1)  # 深拷贝
17

18
# 打印列表元素、列表地址、及其元素地址
19
show_list("nums1", nums1)
20
print()
21
show_list("nums2", nums2)
22
print()
23
"""
24
运行结果：
25
 nums1=[10, 20, 30, [40, 50]]
26
 nums1 的id是：4346019200
27
 nums1 的各个元素的id是：
28
         10 = 4357267904
29
         20 = 4357268224
30
         30 = 4357268544
31
         nums1[3]=[40, 50]
32
         nums1[3] 的id是：4345858048
33
         nums1[3] 的各个元素的id是：
34
                 40 = 4357268864
35
                 50 = 4357269184
36

37
 nums2=[10, 20, 30, [40, 50]]
38
 nums2 的id是：4348067264
39
 nums2 的各个元素的id是：
40
         10 = 4357267904
41
         20 = 4357268224
42
         30 = 4357268544
43
         nums2[3]=[40, 50]
44
         nums2[3] 的id是：4348067456
45
         nums2[3] 的各个元素的id是：
46
                 40 = 4357268864
47
                 50 = 4357269184
48
"""
49
# 修改nums2[3][0] = 99
50
nums2[3][0] = 99
51
print(f"{"*" * 10}修改nums2后{"*" * 10}\n")
52
# 打印列表元素、列表地址、及其元素地址
53
show_list("nums1", nums1)
54
print()
55
show_list("nums2", nums2)
56
print()
57
"""
58
运行结果：
59
**********修改nums2后**********
60

61
 nums1=[10, 20, 30, [40, 50]]
62
 nums1 的id是：4346019200
63
 nums1 的各个元素的id是：
64
         10 = 4357267904
65
         20 = 4357268224
66
         30 = 4357268544
67
         nums1[3]=[40, 50]
68
         nums1[3] 的id是：4345858048
69
         nums1[3] 的各个元素的id是：
70
                 40 = 4357268864
71
                 50 = 4357269184
72

73
 nums2=[10, 20, 30, [99, 50]]
74
 nums2 的id是：4348067264
75
 nums2 的各个元素的id是：
76
         10 = 4357267904
77
         20 = 4357268224
78
         30 = 4357268544
79
         nums2[3]=[99, 50]
80
         nums2[3] 的id是：4348067456
81
         nums2[3] 的各个元素的id是：
82
                 99 = 4357270752
83
                 50 = 4357269184
84
"""

在内存中的逻辑图示：

在修改之后的内存中的逻辑图示：

通过上面的代码，我们可以看出，nums1 和 nums2 是两个不同的列表对象（通过深拷贝，它们的地址不同），并且其中的可变子对象也会被复制，因此它们引用的子对象地址也不同。当我们修改 nums2[3][0] 的值时，实际上是修改了 nums2 列表中的一个元素（一个列表），由于这个元素在内存中是一个可变对象（列表），所以会直接修改这个列表对象中的元素，而不会创建新的对象。由于 nums1[3] 仍然指向原来的列表对象，所以 nums1 中的元素没有发生变化。

拷贝的特殊情况

1. 非容器类型（如数字、字符串、和其他“原子”类型的对象）无法拷贝

2. 元组变量如果只包含原子类型对象，则不能对其深拷贝

在实际编程过程中，我们其实一直都在接触“拷贝”相关的概念。例如在函数传参时，Python 传递的本质是 对象的引用（也可以理解为对象引用的拷贝）。

如果参数是 可变对象（例如 list、dict 等），在函数内部对对象内容进行修改时，可能会影响函数外部的原对象。

如果参数是 不可变对象（例如 int、str、tuple 等），由于对象本身不可修改，在函数内部进行“修改”时实际上会创建新的对象，因此不会影响外部变量。

因此，在处理可变对象时，如果不希望函数内部的操作影响原始数据，就需要考虑是否使用 浅拷贝或深拷贝 来创建独立的数据副本。

总体来说，Python 中变量保存的是对象的引用，而不是对象本身。因此理解“引用关系”和“对象是否可变”，是理解直接赋值、浅拷贝和深拷贝的关键。(:D 可以看看切片他的底层是什么实现的嘞~)