深copy，浅copy，以及修饰符的区别

蔚落 2023-10-14 19:57 30阅读 0赞

##  ##

在编程中，我们经常需要对数据进行复制操作。然而，复制操作不仅涉及到简单的数据拷贝，还包括对数据结构的处理。深copy和浅copy是两种常见的复制方式，而修饰符也可以影响数据的复制行为。本文将深入探讨深copy、浅copy以及修饰符的区别，并通过代码示例演示它们的应用。

![Image][]

### 1. 浅copy ###

浅copy是对数据的一层拷贝，它只复制了数据本身，而没有复制数据引用的对象。换句话说，浅copy仅复制了对象的引用，而不是对象本身。

#### 代码示例 ####

import copy
    
    
    
    # 原始列表
    
    original_list = [1, [2, 3], [4, 5]]
    
    
    
    # 浅copy
    
    shallow_copy_list = copy.copy(original_list)
    
    
    
    # 修改原始列表中的嵌套列表
    
    original_list[1][0] = 'modified'
    
    
    
    # 输出结果
    
    print("原始列表:", original_list)
    
    print("浅copy后的列表:", shallow_copy_list)

#### 运行结果 ####

原始列表: [1, ['modified', 3], [4, 5]]
    
    浅copy后的列表: [1, ['modified', 3], [4, 5]]

从结果可以看出，当修改原始列表中的嵌套列表时，浅copy后的列表也受到了影响。这是因为浅copy只复制了嵌套列表的引用，所以原始列表和浅copy后的列表共享相同的嵌套列表。

### 2. 深copy ###

深copy是对数据的递归拷贝，它会复制数据本身以及数据引用的所有对象。换句话说，深copy会创建一个全新的对象，包括所有嵌套的对象。

#### 代码示例 ####

import copy
    
    
    
    # 原始列表
    
    original_list = [1, [2, 3], [4, 5]]
    
    
    
    # 深copy
    
    deep_copy_list = copy.deepcopy(original_list)
    
    
    
    # 修改原始列表中的嵌套列表
    
    original_list[1][0] = 'modified'
    
    
    
    # 输出结果
    
    print("原始列表:", original_list)
    
    print("深copy后的列表:", deep_copy_list)

#### 运行结果 ####

原始列表: [1, ['modified', 3], [4, 5]]
    
    深copy后的列表: [1, [2, 3], [4, 5]]

从结果可以看出，修改原始列表中的嵌套列表并不影响深copy后的列表。这是因为深copy递归地复制了所有嵌套的对象，所以原始列表和深copy后的列表互不影响。

### 3. 修饰符 ###

在一些编程语言中，我们可以使用一些修饰符来控制复制操作的行为。例如，在Python中，我们可以使用`copy`模块的`copy()`函数来进行浅copy，使用`copy.deepcopy()`函数来进行深copy。此外，Python还提供了一些修饰符来实现更灵活的复制操作。

#### `__copy__()` ####

`__copy__()`方法是Python中用于浅copy的特殊方法。如果一个对象实现了`__copy__()`方法，那么在进行浅copy时，Python会调用该方法来创建新对象。

#### `__deepcopy__()` ####

`__deepcopy__()`方法是Python中用于深copy的特殊方法。如果一个对象实现了`__deepcopy__()`方法，那么在进行深copy时，Python会调用该方法来创建新对象。

#### 代码示例 ####

import copy
    
    
    
    class MyClass:
    
     def __init__(self, value):
    
    •    self.value = value
    
    
    
     def __copy__(self):
    
    •    print("调用了__copy__()方法")
    
    •    return MyClass(self.value)
    
    
    
     def __deepcopy__(self, memo):
    
    •    print("调用了__deepcopy__()方法")
    
    •    return MyClass(copy.deepcopy(self.value, memo))
    
    
    
    # 原始对象
    
    obj = MyClass([1, 2, 3])
    
    
    
    # 浅copy
    
    shallow_copy_obj = copy.copy(obj)
    
    
    
    # 深copy
    
    deep_copy_obj = copy.deepcopy(obj)

#### 运行结果 ####

调用了__copy__()方法
    
    调用了__deepcopy__()方法

从结果可以看出，在进行浅copy时，Python调用了对象的`__copy__()`方法；而在进行深copy时，Python调用了对象的`__deepcopy__()`方法。

### 4. 总结 ###

深copy和浅copy是在编程中常用的两种复制方式，它们的区别在于复制的深度。浅copy只复制一层数据，而深copy会递归地复制所有嵌套的对象。在Python中，我们可以使用`copy`模块的`copy()`函数和`deepcopy()`函数来实现浅copy和深copy操作。另外，对于某些需要更灵活控制复制行为的情况，我们可以通过实现对象的`__copy__()`和`__deepcopy__()`方法来自定义复制操作。

在使用深copy时需要注意避免出现循环引用的情况，否则可能会导致无限递归而导致程序崩溃。为了避免这种情况，`copy`模块中的`deepcopy()`函数接受一个可选的`memo`参数，用于存储已经复制过的对象，从而避免重复复制。

对于一些特殊的数据类型，例如自定义的对象、嵌套的数据结构等，深copy和浅copy的行为可能会有所不同。因此，在实际应用中，我们需要根据具体情况选择合适的复制方式，以确保数据的正确性和完整性。

在总结本文之前，我们再来看一个使用深copy的实际案例。

#### 案例：复制嵌套字典 ####

import copy
    
    
    
    # 原始字典
    
    original_dict = {'a': 1, 'b': {'c': 2, 'd': 3}}
    
    
    
    # 深copy
    
    deep_copy_dict = copy.deepcopy(original_dict)
    
    
    
    # 修改原始字典中的嵌套字典
    
    original_dict['b']['c'] = 'modified'
    
    
    
    # 输出结果
    
    print("原始字典:", original_dict)
    
    print("深copy后的字典:", deep_copy_dict)

运行结果：

原始字典: {'a': 1, 'b': {'c': 'modified', 'd': 3}}
    
    深copy后的字典: {'a': 1, 'b': {'c': 2, 'd': 3}}

从结果可以看出，修改原始字典中的嵌套字典并不影响深copy后的字典。这是因为深copy递归地复制了所有嵌套的对象，所以原始字典和深copy后的字典互不影响。

### 结论 ###

本文深入探讨了深copy、浅copy以及修饰符的区别，并通过代码示例演示了它们的应用。深copy会复制数据本身以及所有嵌套的对象，而浅copy只复制一层数据。修饰符可以自定义复制操作的行为，适用于某些特殊的数据类型。

在实际开发中，我们需要根据数据结构和复制需求来选择合适的复制方式，以确保数据的正确性和完整性。同时，要注意避免循环引用和无限递归的情况，保证复制操作的安全性和性能。通过灵活使用深copy、浅copy和修饰符，我们可以更好地处理数据复制问题，提高代码的可维护性和扩展性，成为一名合格的iOS程序员。

[Image]: https://img-blog.csdnimg.cn/img_convert/55b6d13bf2dd7f4cea38a9e45060801c.jpeg