Python中的深拷贝与浅拷贝

        Pyhon中的id()可以获取变量指向的内存地址，变量赋值时内存地址是不变的。对于可变数据类型，值发生改变，内存地址不变；对于不可变数据类型，值发生改变，内存地址就会发生改变。

# 定义一个变量a
a = '123'
print("变量a的内存地址为:", id(a))
 
# 把变量a赋值给变量b
b = a
print("将变量a赋值给变量b后，变量b的内存地址为:", id(b))



# 定义一个变量 list_var，赋值为列表 [2, 4, 6]
list_var = [2, 4, 6]
print("初始列表 [2, 4, 6] 的内存地址:", id(list_var))

# 修改列表，添加一个元素
list_var.append(8)
print("修改后列表 [2, 4, 6, 8] 的内存地址:", id(list_var))

# 定义一个变量 tuple_var，赋值为元组 (7, 9, 11)
tuple_var = (7, 9, 11)
print("初始元组 (7, 9, 11) 的内存地址:", id(tuple_var))

# 重新赋值给变量 tuple_var
tuple_var = (13, 9, 11)
print("修改后元组 (13, 9, 11) 的内存地址:", id(tuple_var))

变量a的内存地址为: 3029793538480
将变量a赋值给变量b后，变量b的内存地址为: 3029793538480

初始列表 [2, 4, 6] 的内存地址: 2255113377216
修改后列表 [2, 4, 6, 8] 的内存地址: 2255113377216
初始元组 (7, 9, 11) 的内存地址: 2255114739008
修改后元组 (13, 9, 11) 的内存地址: 2255115178432 

浅拷贝

• 可变数据类型：浅拷贝对原来的值进行拷贝，并且开辟新的内存空间，但是不能为内层开辟新的内存空间
• 不可变数据类型：浅拷贝对原来的值进行拷贝，不开辟新的内存空间

import copy

# 可变数据类型
my_list = [1, 2, 3, [4, 5]]

# 浅拷贝
my_list_copy = copy.copy(my_list)

print("可变数据类型进行浅拷贝前后的内存地址:\n", id(my_list), id(my_list_copy))
print("可变数据类型进行浅拷贝前后，内层的内存地址:\n", id(my_list[-1]), id(my_list_copy[-1]))

# 可变数据类型
my_tuple = (1, 2, 3, (4, 5))

# 浅拷贝
my_tuple_copy = copy.copy(my_tuple)

print("不可变数据类型进行浅拷贝前后的内存地址:\n", id(my_tuple), id(my_tuple_copy))
print("不可变数据类型进行浅拷贝前后，内层的内存地址:\n", id(my_tuple[-1]), id(my_tuple_copy[-1]))

 可变数据类型进行浅拷贝前后的内存地址:
 2108467304832 2108467267136
可变数据类型进行浅拷贝前后，内层的内存地址:
 2108466283072 2108466283072
不可变数据类型进行浅拷贝前后的内存地址:
 2108466821728 2108466821728
不可变数据类型进行浅拷贝前后，内层的内存地址:
 2108466283072 2108466283072

深拷贝 

• 可变数据类型：深拷贝对原来的值进行拷贝，并且开辟新的内存空间
• 不可变数据类型：深拷贝对原来的值进行拷贝，不开辟新的内存空间

import copy

# 可变数据类型
my_list = [1, 2, 3, [4, 5]]

# 浅拷贝
my_list_copy = copy.deepcopy(my_list)

print("可变数据类型进行深拷贝前后的内存地址:\n",id(my_list), id(my_list_copy))
print("可变数据类型进行深拷贝前后，内层的内存地址:\n", id(my_list[-1]), id(my_list_copy[-1]))

# 可变数据类型
my_tuple = (1, 2, 3, (4, 5))

# 浅拷贝
my_tuple_copy = copy.deepcopy(my_tuple)

print("不可变数据类型进行深拷贝前后的内存地址:\n", id(my_tuple), id(my_tuple_copy))
print("不可变数据类型进行深拷贝前后，内层的内存地址:\n", id(my_tuple[-1]), id(my_tuple_copy[-1]))

 可变数据类型进行深拷贝前后的内存地址:
 2275346499136 2275346541376
可变数据类型进行深拷贝前后，内层的内存地址:
 2275346536832 2275346534144
不可变数据类型进行深拷贝前后的内存地址:
 2275346049488 2275346049488
不可变数据类型进行深拷贝前后，内层的内存地址:
 2275345515072 2275345515072

 特殊情况

• 可变嵌套不可变：深、浅拷贝原来的值进行拷贝，并且开辟新的内存空间，但是不能为内层开辟新的内存空间
• 不可变嵌套可变：深、浅拷贝原来的值进行拷贝，但浅拷贝不开辟新的内存空间，而深拷贝进行完整拷贝

import copy

# 可变嵌套不可变
s1 = [1, 2, 3, (4, 5)]
s1_copy = copy.copy(s1)
s1_deepcopy = copy.deepcopy(s1)

print("可变嵌套不可变类型进行浅、深拷贝前后的内存地址:\n", id(s1), id(s1_copy), id(s1_deepcopy))
print("可变嵌套不可变类型进行浅、深拷贝前后，内层的内存地址:\n", id(s1[-1]), id(s1_copy[-1]), id(s1_deepcopy[-1]))

# 不可变嵌套可变
s2 = (1, 2, 3, [4, 5])
s2_copy = copy.copy(s2)
s2_deepcopy = copy.deepcopy(s2)

print("不可变嵌套可变类型进行浅、深拷贝前后的内存地址:\n", id(s2), id(s2_copy), id(s2_deepcopy))
print("不可变嵌套可变类型进行浅、深拷贝前后，内层的内存地址:\n", id(s2[-1]), id(s2_copy[-1]), id(s2_deepcopy[-1]))

 可变嵌套不可变类型进行浅、深拷贝前后的内存地址:
 1762055215488 1762055177792 1762055220032
可变嵌套不可变类型进行浅、深拷贝前后，内层的内存地址:
 1762054193728 1762054193728 1762054193728
不可变嵌套可变类型进行浅、深拷贝前后的内存地址:
 1762054728224 1762054728224 1762054726784
不可变嵌套可变类型进行浅、深拷贝前后，内层的内存地址:
 1762055212800 1762055212800 1762055220288