黑马程序员---浅拷贝和深拷贝

一：浅拷贝：

# 1： 对于不可变类型进行拷贝没有意义。拷贝的目的是解决变量地址公用的问题，不可变类型不会公用地址。
# 2：浅拷贝只拷贝第一层对象，不会拷贝内部的子对象。
import copy

# 地址引用 ：不可变类型改变一个不会影响另一个。可变类型一个改，都改。
# 可变类型： 字典，列表，集合
# 不可变类型：数字，元组，字符串

num1 = 1
num2 = num1
print(num1, id(num1))
print(num2, id(num2))
num1 = 2
print(num1, id(num1))
print(num2, id(num2))
#
# 结果：
# 1 1559527536
# 1 1559527536
# 2 1559527568
# 1 1559527536
# 通过结果发现，不可变类型，一个改了，不会影响另外一个。
print("-"*30)

list1 = [11, 22, 33]
list2 = list1
print("list1:", list1)
print("list2:", list2)

list2.append(44)
print("list1:", list1, id(list1))
print("list2:", list2, id(list2))
# 通过这个我们可以看到，修改其中一个，另一个值也发生改变。这样就互相影响了，为了消除这种影响，所以才引进拷贝。
#结果：
# list1: [11, 22, 33]
# list2: [11, 22, 33]
# list1: [11, 22, 33, 44] 1891320380168
# list2: [11, 22, 33, 44] 1891320380168

print("-"*30)
# 1:验证不可变类型拷贝，地址不变，相当于地址引用

num1 = 1
num2 = copy.copy(num1)
print("num1的id:", id(num1))
print("num2的id:", id(num2))

# 运行结果
# num1的id: 1559527536
# num2的id: 1559527536
print("_"*30)


# 2:浅拷贝可变类型：
list1 = [1, 2]
list2 = copy.copy(list1)
print("查看list1的id:", id(list1))
print("查看list2的id:", id(list2))
# 运行结果:
# 查看list1的id: 1881173541832
# 查看list2的id: 1881174884104

print("_"*30)
# 如果第一层是不可变类型，内层有可变类型，浅拷贝不会拷贝
my_touple1 = (1, 2, [3, 4])
my_touple2 = copy.copy(my_touple1)
print(my_touple1)
print(my_touple2)
print("查看my_touple1的id:", id(my_touple1))
print("查看my_touple2的id:", id(my_touple2))

# 我们发现没有进行拷贝,相当于引用赋值
# (1, 2, [3, 4])
# (1, 2, [3, 4])
# 查看my_touple1的id: 2247007170848
# 查看my_touple2的id: 2247007170848

print("----------------------")
# 浅拷贝会不会影响内层的对象？这里发现随着浅拷贝，内层地址不会改变，只改变最外层的地址。
my_list1 = [1, 2, 3, [4, 5]]
my_list2 = copy.copy(my_list1)
print(my_list1)
print(my_list2)
print("查看my_list1的id:", id(my_list1))
print("查看my_list2的id:", id(my_list2))
print("查看my_list1内层的id:", id(my_list1[3]))
print("查看my_list2内层的id:", id(my_list2[3]))
# [1, 2, 3, [4, 5]]
# [1, 2, 3, [4, 5]]
# 查看my_list1的id: 2782136352648
# 查看my_list2的id: 2782136352584
# 查看my_list1内层的id: 2782136352712
# 查看my_list2内层的id: 2782136352712

二：深拷贝：

# deepcopy函数是深拷贝, 只要发现对象有可变类型就会对该对象到最后一个可变类型的每一层对象就行拷贝,
# 对每一层拷贝的对象都会开辟新的内存空间进行存储。
import copy
# 1：外层是不可变类型，内层存在可变类型，会不会拷贝呢 ？
num1 = (1, [2, 3])
num2 = copy.deepcopy(num1)
print(num1)
print(num2)
print("num1的id:", id(num1))
print("num2的id:", id(num2))
print("num1的内层id:", id(num1[1]))
print("num2的内层id:", id(num2[1]))

# 发现内层和外层地址都改变了

# (1, [2, 3])
# (1, [2, 3])
# num1的id: 2704953082056
# num2的id: 2704952970696
# num1的内层id: 2704954538760
# num2的内层id: 2704954539784

print("-"*30)
# 2:深拷贝是到最里面有不可变的那一层，还是所有层都拷贝呢？
num1 = (1, [2, 3, (4, 5, 6)])
num2 = copy.deepcopy(num1)
print(num1)
print(num2)
print("num1的id:", id(num1))
print("num2的id:", id(num2))
print("num1的内层id:", id(num1[1]))
print("num2的内层id:", id(num2[1]))
print("num1的内层id:", id(num1[1][2]))
print("num2的内层id:", id(num2[1][2]))
# 我们发现最内层元组地址是相同的。

# (1, [2, 3, (4, 5, 6)])
# (1, [2, 3, (4, 5, 6)])
# num1的id: 1727262543624
# num2的id: 1727262523592
# num1的内层id: 1727263981256
# num2的内层id: 1727262639048
# num1的内层id: 1727262454048
# num2的内层id: 1727262454048