【Python】深拷贝和浅拷贝详解

古城微笑少年丶 2023-01-23 09:59 41阅读 0赞

### 深拷贝和浅拷贝详解 ###

*  浅拷贝
 *   *  浅拷贝注意事项
 *  深拷贝
 *   *  深拷贝注意事项

> 浅拷贝（shallow copy）、深度拷贝（deep copy）

# 浅拷贝 #

常见的浅拷贝的方法，是使用数据类型本身的构造器，比如下面两个例子：

list1 = [1, 2, 3]
    list2 = list(list1)
    print(list2)
    print("list1==list2 ?",list1==list2)
    print("list1 is list2 ?",list1 is list2)
    输出：
    [1, 2, 3]
    list1==list2 ? True
    list1 is list2 ? False
    =====================================
    set1= set([1, 2, 3])
    set2 = set(set1)
    print(set2)
    print("set1==set2 ?",set1==set2)
    print("set1 is set2 ?",set1 is set2)
    输出：
    {
        1, 2, 3}
    set1==set2 ? True
    set1 is set2 ? False

在上面程序中，list2 就是 list1 的浅拷贝，同理 set2 是 set1 的浅拷贝。

当然，对于可变的序列，还可以通过切片操作符`“：”`来完成浅拷贝，例如：

list1 = [1, 2, 3]
    list2 = list1[:]
    print(list2)
    print("list1 == list2 ?",list1 == list2)
    print("list1 is list2 ?",list1 is list2)
    输出：
    [1, 2, 3]
    list1 == list2 ? True
    list1 is list2 ? False

除此之外，Python 还提供了对应的函数 `copy.copy() 函数`，适用于任何数据类型。其用法如下：

import copy
    list1 = [1, 2, 3]
    list2 = copy.copy(list1)
    print(list2)
    print("list1 == list2 ?",list1 == list2)
    print("list1 is list2 ?",list1 is list2)
    输出：
    [1, 2, 3]
    list1 == list2 ? True
    list1 is list2 ? False

注意，对于元组，使用 `tuple()` 或者`切片操作符 ':'`不会创建一份浅拷贝，相反它会返回一个指向相同元组的引用：

tuple1 = (1, 2, 3)
    tuple2 = tuple(tuple1)
    print(tuple2)
    print("tuple1 == tuple2 ?",tuple1 == tuple2)
    print("tuple1 is tuple2 ?",tuple1 is tuple2)
    输出：
    (1, 2, 3)
    tuple1 == tuple2 ? True
    tuple1 is tuple2 ? True

浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。

## 浅拷贝注意事项 ##

对数据采用浅拷贝的方式时，如果原对象中的元素不可变，那倒无所谓；

但如果元素可变，浅拷贝通常会出现一些问题，例如：

list1 = [[1, 2], (30, 40)]
    list2 = list(list1)
    list1.append(100)
    print("list1:",list1) 输出：list1: [[1, 2], (30, 40), 100]
    print("list2:",list2) 输出：list2: [[1, 2], (30, 40)]
    
    list1[0].append(3)
    print("list1:",list1) 输出：list1: [[1, 2, 3], (30, 40), 100]
    print("list2:",list2) 输出：list2: [[1, 2, 3], (30, 40)]
    
    list1[1] += (50, 60)
    print("list1:",list1) 输出：list1: [[1, 2, 3], (30, 40, 50, 60), 100]
    print("list2:",list2) 输出：list2: [[1, 2, 3], (30, 40)]

此程序中，首先初始化了 `list1` 列表，包含一个列表和一个元组；然后对 `list1` 执行浅拷贝，赋予 `list2`。因为浅拷贝里的元素是对原对象元素的引用，因此 `list2` 中的元素和 `list1` 指向同一个列表和元组对象。

接着往下看，`list1.append(100)` 表示对 `list1` 的列表新增元素 100。这个操作不会对 `list2` 产生任何影响，因为 `list2` 和 `list1` 作为整体是两个不同的对象，并不共享内存地址。操作过后 `list2` 不变，`list1` 会发生改变。

再来看，`list1[0].append(3)` 表示对 `list1` 中的第一个列表`新增元素 3`。因为 `list2` 是 `list1` 的浅拷贝，`list2` 中的第一个元素和 `list1` 中的第一个元素，共同指向同一个列表，因此 list2 中的第一个列表也会相对应的新增元素 3。

最后是 `list1[1] += (50, 60)`，因为元组是不可变的，这里表示对 `list1` 中的第二个元组拼接，然后重新创建了一个新元组作为 `list1` 中的第二个元素，而 list2 中没有引用新元组，因此 list2 并不受影响。

# 深拷贝 #

通过上面的例子，可以很清楚地看到使用浅拷贝可能带来的副作用。如果想避免这种副作用，完整地拷贝一个对象，就需要使用深拷贝。

所谓深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。

Python 中以 `copy.deepcopy()` 来实现对象的深度拷贝。比如上述例子写成下面的形式，就是深度拷贝：

import copy
    list1 = [[1, 2], (30, 40)]
    list2 = copy.deepcopy(list1)
    list1.append(100)
    print("list1:",list1) 输出：list1: [[1, 2], (30, 40), 100]
    print("list2:",list2) 输出：list2: [[1, 2], (30, 40)]
    
    list1[0].append(3)
    print("list1:",list1) 输出：list1: [[1, 2, 3], (30, 40), 100]
    print("list2:",list2) 输出：list2: [[1, 2], (30, 40)]
    
    list1[1] += (50, 60)
    print("list1:",list1) 输出：list1: [[1, 2, 3], (30, 40, 50, 60), 100]
    print("list2:",list2) 输出：list2: [[1, 2], (30, 40)]

可以看到，无论 `list1` 如何变化，`list2` 都不变。因为此时的 list1 和 list2 完全独立，没有任何联系。

## 深拷贝注意事项 ##

不过，深度拷贝也不是完美的，往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环，例如：

import copy
    
    list1 = [1]
    list1.append(list1)
    print(list1) 输出：[1, [...]]
    
    list2 = copy.deepcopy(list1)
    print(list2) 输出：[1, [...]]

此例子中，列表 x 中有指向自身的引用，因此 x 是一个无限嵌套的列表。

但是当深度拷贝 x 到 y 后，程序并没有出现栈溢出的现象。这是为什么呢？

其实，这是因为深度拷贝函数 `deepcopy 中会维护一个字典`，记录已经拷贝的对象与其 ID。

拷贝过程中，如果字典里已经存储了将要拷贝的对象，则会从字典直接返回。通过查看 `deepcopy` 函数实现的源码就会明白：

def deepcopy(x, memo=None, _nil=[]):
        """Deep copy operation on arbitrary Python objects.
           
        See the module's __doc__ string for more info.
        """
       
        if memo is None:
            memo = {
        }
        d = id(x) # 查询被拷贝对象 x 的 id
        y = memo.get(d, _nil) # 查询字典里是否已经存储了该对象
        if y is not _nil:
            return y # 如果字典里已经存储了将要拷贝的对象，则直接返回
            ...