浅拷贝与深拷贝(含代码示例)

Dear 丶 2022-10-11 12:26 173阅读 0赞

关于浅拷贝和深拷贝的问题，如果你没有接触过，在进行一些基本的编程时，可能一般不会受到任何影响，但是倘若因为这个出了问题肯定是一脸懵，所以需要去了解这块的内容，进一步去理解python的内存分配的相关内容。

### 目录 ###

*  浅拷贝
 *  深拷贝
 *  关于\[\[0\] \* m\] \* n

首先，根据例子去感受浅拷贝和深拷贝：

# 浅拷贝 #

>>> a = [1, 2, 3, 4]
    >>> b = list(a)
    >>> b
    [1, 2, 3, 4]
    >>> a == b
    True
    >>> a is b
    False

这里的b就是a的浅拷贝，对于可变的序列，还可以通过切片操作符" : "完成浅拷贝：

>>> a = [1, 2, 3, 4]
    >>> c = a[:]
    >>> c == a
    True
    >>> c is a
    False
    >>>

另外，python中也提供了copy.copy()方法，适用于任何数据类型（包含dict、list、set等）的浅拷贝。

>>> a = [1, 2, 3, 4]
    >>> import copy
    >>> d = copy.copy(a)
    >>> d == a
    True
    >>> d is a
    False
    >>>

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

>>> t1 = (1, 2, 3, 4)
    >>> t2 = tuple(t1)
    >>> t1 == t2
    True
    >>> t1 is t2
    True
    >>> t3 = t1[:]
    >>> t3 == t1
    True
    >>> t3 is t1
    True
    >>> t4 = copy.copy(t1)
    >>> t4 == t1
    True
    >>> t4 is t1
    True
    >>>

元组 (1, 2, 3, 4) 只被创建一次，t1 、t2、t3、t4 同时指向这个元组。

通过上面的这些例子，总结一下：浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用。因此，如果原对象中的元素不可变，那倒无所谓；但如果元素可变，浅拷贝通常会带来一些副作用，尤其需要注意。

>>> a= [[1, 2], (30, 40)]
    >>> b= list(a)
    >>> a.append(100)
    >>> a[0].append(3)
    
    >>> a
    [[1, 2, 3], (30, 40), 100]
    
    >>> b
    [[1, 2, 3], (30, 40)]
    
    >>> a[1] += (50, 60)
    >>> a
    [[1, 2, 3], (30, 40, 50, 60), 100]
    
    >>> b
    [[1, 2, 3], (30, 40)]

代码分析：

我们首先初始化了一个列表 a，里面的元素是一个列表和一个元组；然后对a执行浅拷贝，赋予 b。因为浅拷贝里的元素是对原对象元素的引用，因此 b中的元素和a指向同一个列表和元组对象。

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

再来看，a\[0\].append(3)，这里表示对 a中的第一个列表新增元素 3。因为 b是 a的浅拷贝，b中的第一个元素和 a中的第一个元素，共同指向同一个列表，因此 b中的第一个列表也会相对应的新增元素 3。操作后 a和 b都会改变.

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

通过这个例子，很清楚地看到使用浅拷贝可能带来的副作用。因此，如果我们想避免这种副作用，完整地拷贝一个对象，这时就得使用深度拷贝。

# 深拷贝 #

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

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

import copy
    
    
    >>> a= [[1, 2], (30, 40)]
    >>> b= copy.deepcopy(a)
    >>> a.append(100)
    >>> a[0].append(3)
    
    >>> a
    [[1, 2, 3], (30, 40), 100]
    
    >>> b
    [[1, 2], (30, 40)]

无论a 如何变化，b都不变。因为此时的 a和 b完全独立，没有任何联系.

# 关于\[\[0\] \* m\] \* n #

>>> m = 3
    >>> n = 2
    >>> L = [[0] * m] * n
    >>> L
    [[0, 0, 0], [0, 0, 0]]
    >>>

当修改第一个L\[0\]时：

>>> L[0][0] = 1
    >>> L
    [[1, 0, 0], [1, 0, 0]]

可以看到L\[1\]中的列表也被修改了，通过is判断，二者是否指向同一块内存

>>> L[0] is L[1]
    True
    >>>

可以看出二者指向同一块内存，所以采用的是浅拷贝。

如果想要避免这样的副作用，可以这样构建：

>>> L = [[0 for _ in range(m)] for _ in range(n)]
    >>> L
    [[0, 0, 0], [0, 0, 0]]
    
    >>> L[0][0] = 1
    
    >>> L
    [[1, 0, 0], [0, 0, 0]]

参考：  
https://cloud.tencent.com/developer/article/1625359