随笔录--不可变数据类型对深浅拷贝的影响

1.python的可变数据类型和不可变数据类型

在Python中，数据类型可以分为可变（mutable）和不可变（immutable）两种类型。
这指的是数据类型在创建后是否可以被修改。以下是一些常见的可变和不可变数据类型：
**不可变数据类型（Immutable Data Types）：**1. **整数（int）**：整数是不可变的，一旦创建，其值不能被修改。2. **浮点数（float）**：浮点数也是不可变的，一旦创建，其值不能被修改。3. **字符串（str）**：字符串是不可变的，一旦创建，其内容不能被修改。4. **元组（tuple）**：元组是不可变的，一旦创建，其元素和结构不能被修改。
**可变数据类型（Mutable Data Types）：**1. **列表（list）**：列表是可变的，可以添加、删除、修改其中的元素。2. **字典（dict）**：字典是可变的，可以添加、删除、修改其中的键值对。3. **集合（set）**：集合是可变的，可以添加、删除其中的元素。
不可变数据类型的特点是一旦创建后无法修改其值，而可变数据类型允许在创建后修改其内容。
这些特点对于数据的管理和处理都有重要影响。
需要注意的是，当你对一个不可变数据类型的变量进行修改时，
实际上是创建了一个新的对象，并将变量引用指向新的对象
。而对可变数据类型的修改则是直接在原始对象上进行操作。
这种行为在内存管理和性能方面有一些重要的影响，特别是在处理大型数据集时。

2.如何修改元组中的值

在Python中，元组（tuple）是不可变的数据结构，这意味着一旦创建了元组，就不能修改其中的元素值。如果你想修改元组中的值，你需要创建一个新的元组来代替旧的元组。以下是一个示例代码，演示如何通过创建新的元组来实现修改元组中的值：

```python
# 原始元组
original_tuple = (1, 2, 3, 4, 5)

# 要修改的元素的索引和新值
index_to_modify = 2
new_value = 10

# 将原始元组转换为列表，修改值，然后再转换回元组
tuple_as_list = list(original_tuple)
tuple_as_list[index_to_modify] = new_value
modified_tuple = tuple(tuple_as_list)

print("原始元组:", original_tuple)
print("修改后的元组:", modified_tuple)
```

在这个示例中，我们首先将原始元组转换为列表，然后通过列表的索引来修改需要修改的元素的值，最后再将修改后的列表转换回元组。需要注意的是，这种方法实际上是创建了一个新的元组，而不是在原始元组上进行修改。

如果你需要经常修改元素的值，你可能应该考虑使用列表而不是元组，因为列表是可变的数据结构，允许直接修改元素值。

3.元组实现深浅拷贝

元组（tuple）是不可变的数据结构，因此它在进行深拷贝和浅拷贝时表现与其他可变数据结构有些不同。在元组中的元素是不可修改的，所以实际上元组没有需要深拷贝的嵌套结构，因为无法修改元组内部的元素。但是你仍然可以使用浅拷贝来复制元组对象本身。以下是示例代码：

```python
import copy

original_tuple = (1, 2, [3, 4])
shallow_copy_tuple = copy.copy(original_tuple)
deep_copy_tuple = copy.deepcopy(original_tuple)

# 修改复制后的对象中的可变对象
shallow_copy_tuple[2][0] = 10
deep_copy_tuple[2][0] = 20

print("原始元组:", original_tuple)
print("浅拷贝元组:", shallow_copy_tuple)
print("深拷贝元组:", deep_copy_tuple)
```

在这个示例中，虽然元组本身不会被修改，但是元组中的可变对象（列表）可以被修改。浅拷贝和深拷贝的区别在于是否对可变对象进行递归复制。通过浅拷贝，复制后的元组仍然与原始元组共享相同的可变对象。通过深拷贝，复制后的元组中的可变对象是全新的，与原始元组没有关联。

需要注意的是，元组的元素本身是不可修改的，所以在元组中使用浅拷贝和深拷贝的区别可能没有在可变数据结构中那么明显。深拷贝在处理嵌套的可变对象时才会产生真正的区别。

效果如下

4.列表实现深浅拷贝

在Python中，列表是可变的数据类型，因此在进行深拷贝和浅拷贝时，列表的嵌套结构会影响拷贝行为。下面我将展示如何使用 `copy` 模块来进行深拷贝和浅拷贝。

```python
import copy

# 原始列表
original_list = [[1, 2, 3], [4, 5, 6]]

# 进行浅拷贝
shallow_copy_list = copy.copy(original_list)

# 进行深拷贝
deep_copy_list = copy.deepcopy(original_list)

# 修改拷贝后的对象中的可变对象
shallow_copy_list[0][0] = 10
deep_copy_list[0][1] = 20

print("原始列表:", original_list)
print("浅拷贝列表:", shallow_copy_list)
print("深拷贝列表:", deep_copy_list)
```

在这个示例中，我们使用 `copy.copy()` 进行浅拷贝，和 `copy.deepcopy()` 进行深拷贝。浅拷贝创建了一个新的列表，其中的子列表与原始列表中的子列表共享相同的内部对象。深拷贝则递归地复制了整个嵌套结构，包括子列表，使得拷贝后的对象与原始对象没有任何共享。

需要注意的是，深拷贝适用于复杂的嵌套数据结构，但在某些情况下可能会导致性能较差。浅拷贝则对于只有一层嵌套的简单情况来说是足够的。根据你的实际需求，选择适合的拷贝方式。

效果如下