Python可变数据与不可变数据和标准库copy的使用

什么是可变数据和不可变数据

当一个数据的值发生变化，如果它的内存地址没有发生变化，就说明这是一个可变数据。反之就是一个不可变数据。也就是说，不可变数据的值进行修改，其在内存上的变化就是重新开辟一个新的内存空间，并指向此空间。而可变数据不会在进行内存空间的开辟销毁工作，而是在原地址上直接进行数据的修改。

在前文中我们讲过python变量的缓存机制，在那里我们就说过，对于list、set、dict这三种类型的数据在任何的时候都不会使用相同的内存地址。这三种数据就是各自独立的使用自己的空间，不需要共享地址，所以可以在原位置上直接进行修改，所以也就是可变数据。而除此之外的其它类型的数据自然也就是不可变数据了。

我们来举一个例子，整型就是不可变数据，那么我们现在创建一个值为100的变量a，然后让这个数值发生变化，观察者个变量的内存地址是否发生了变化。

a = 100
print(a, id(a)) # 100 1610845392

a += 100
print(a, id(a)) # 200 1610848592

我们发现数值发生了变化，变量的内存也跟着发生了变化，我们再创建一个变量b，值也是整型100

b = 100
print(b, id(b))	# 100 1610845392

发现b的内存地址和a的内存地址是一样的，也就是说，像整型这样的数据类型，一个数字就独占一个内存地址，当某个指向这个值的变量，发生了变化的时候，不是这个变量的值要改变，而是这个变量要寻找改变后的值的内存地址，然后重新的指向它。只要你的硬件不重新启动，那么这个内存地址就永远也不会发生变化，这样的数据就是不可变数据。

那么，反之就是可变数据，指的就是当变量指向的值发生变化之后，在这个内存地址上的值实打实的发生变化的值，就是可变数据类型。

比如列表，列表发生改变之后，是在原有的基础上发生变化的，所以内存地址是不会改变的，这就是可变数据类型，可变数据类型没有内存缓存机制，不能节省内存，所以一模一样的数据，他们的内存地址可能是不相同的。

a = [1, 2]
print(a, id(a)) # [1, 2] 1528536069896

a.append(3)
print(a, id(a)) # [1, 2, 3] 1528536069896

# b 和 a的值相同，但是内存地址不相同
b = [1, 2, 3]
print(b, id(b)) # [1, 2, 3] 1528536069832

拷贝函数的使用场景

拷贝函数是专门为可变数据类型list、set、dict使用的一种函数。作用是，当一个值指向另一个值的时候，也不会影响指向的值，如果被指向的数据是可变数据，那么它一旦被修改，指向的数据也会随之改变。

在我们的实际工作当中，我们经常会使用的一种操作就是，将一个旧的变量的值直接赋值给一个新的变量，然后对新的变量进行操作。当然，在进行其它的使用操作之前，这两个变量的值一定是相同的， 但是我们之所以不直接对旧的变量进行操作，而是要对新的变量进行操作，是因为我们不想要原数据发生改变。

那么这就是问题的所在，如果这个数据是一个不可变数据，那么新变量的值在发生变化之后，不会在原地址上进行修改，而是重新指向一个新的地址，这样旧变量的值就不会发生变化。但是如果这个数据是一个可变数据，它会直接在原地址上进行修改，导致旧变量的值也发生了变化。这不是我们所想要的结果。

我们拿整型为例，变量a直接赋值给变量b，这个时候a变量和b变量的值是相同的，但是如果变量a或者变量b的值发生了变化，是丝毫不会影响对方的值。

a = 100
print(a, id(a))  # 100 1610845392

b = a
print(b, id(b))  # 100 1610845392

a += 100
print(a, id(a))  # 200 1610848592
print(b, id(b))  # 100 1610845392

但如果是一个可变数据，比如说list，那么情况就不一样了：

a = [1, 2]
print(a, id(a))  # [1, 2] 2077688035080

b = a
print(b, id(b))  # [1, 2] 2077688035080

a.append(3)
print(a, id(a))  # [1, 2, 3] 2077688035080
print(b, id(b))  # [1, 2, 3] 2077688035080

不可变数据的这个特性既是一个优点也是一个缺点，缺点就是如果我们想要保存a变量发生变化之前的的一个状况的时候，是保存不下来的，这个时候就出现了拷贝函数。

拷贝函数

拷贝函数只的是python标准库copy当中的两个函数，copy()和deepcopy()分别表示浅拷贝和深拷贝。

浅拷贝

如果直接将a变量的值赋值给b变量，那么双方的地址指向是相同的，在加上双方的数据如果是可变数据，那么就会在原地址上进行数据的修改，导致双方的值都发生变化。

但是如果使用了拷贝函数，在将a变量的值赋值给b变量的时候，就不再是简单的将b变量指向a变量的地址，而是在内存中新开辟一个空间，供b变量使用，这样因为本身内存地址的不同，所以双方的数据进行操作，就不会影响到对方的数据了。

# 使用拷贝函数需要先导入标准库copy
import copy

a = [1, 2, 3]

# 不再直接将a变量的值赋值给b变量，而是将copy的返回值赋值给b变量
b = copy.copy(a)

# 他们的数值一样，但是内存地址不同，所以他们之间的任意一方发生变化都不会影响到对方
print(a, id(a))  # [1, 2, 3] 2343743813320
print(b, id(b))  # [1, 2, 3] 2343743813192

a.append(4)
print(a, id(a))  # [1, 2, 3, 4] 2343743813320
print(b, id(b))  # [1, 2, 3] 2343743813192

深拷贝

需要注意的是，浅拷贝函数copy()只能拷贝一级容器，如果是a变量存在二级即更多层级的容器，是没有办法完全拷贝下来的。所以当第二级容器即更高层级的容器发生变化的时候，依然会影响到对方。

import copy

a = [[66,88], 2, 3]

b = copy.copy(a)

print(a, id(a))  # [[66, 88], 2, 3] 2431683163720
print(b, id(b))  # [[66, 88], 2, 3] 2431683162184

# 改变二级容器
a[0].append(100)
print(a, id(a))  # [[66, 88, 100], 2, 3] 2431683163720
print(b, id(b))  # [[66, 88, 100], 2, 3] 2431683162184

# 发现二级容器的数据依然发生了变化，这是因为浅拷贝不能拷贝二级即以上层级的容器
# 它们的地址还是相同的
print(id(a[0]))  # 1582481372872
print(id(b[0]))  # 1582481372872

所以，对此我们可以使用深拷贝deepcopy()来完成。

import copy

a = [[66,88], 2, 3]

# 深拷贝使用deepcopy函数
b = copy.deepcopy(a)


print(a, id(a))  # [[66, 88], 2, 3] 2168411158088
print(b, id(b))  # [[66, 88], 2, 3] 2168411156552

a[0].append(100)
print(a, id(a))  # [[66, 88, 100], 2, 3] 2168411158088
print(b, id(b))  # [[66, 88], 2, 3] 2168411156552

# 深拷贝所有级别的容器
print(id(a[0]))  # 2168411158216
print(id(b[0]))  # 2168411122760

总结

1. 使用深浅拷贝需要导入copy模块；
2. 浅拷贝使用copy()函数，只能拷贝一级容器的所有元素；
3. 深拷贝使用deepcopy()函数，可以拷贝所有级别容器的所有元素；
4. 标准库copy中只有copy()和deepcopy()两个函数对外开放使用；
5. 因为深拷贝要拷贝的元素更多，所以速度相比浅拷贝会慢一些（在多层容器中最明显），所以在编程的过程中要注意避免造成多余的系统负担；
6. 拷贝函数只适用于可变数据，不可变数据也可以使用拷贝函数，但是没有意义；