深度解析Python的赋值、浅拷贝、深拷贝

蔚落 2022-11-12 10:53 169阅读 0赞

## 简述 ##

*  **直接赋值：** 其实就是对象的引用（别名）。
 *  **浅拷贝(copy)：** 拷贝父对象，不会拷贝对象的内部的子对象。
 *  **深拷贝(deepcopy)：** `copy` 模块的 `deepcopy` 方法，完全拷贝了父对象及其子对象。

**拷贝** 就是把原数据复制一份，在复制的数据上随意改动不会影响到其原数据。也就是这里讲的深拷贝。

## 直接赋值 ##

In [1]: a = [11, 22, 33]
    
    In [2]: b = a
    
    In [3]: b
    Out[3]: [11, 22, 33]
    
    In [4]: id(a), id(b)
    Out[4]: (2053851155016, 2053851155016)
    
    In [5]: c = { "name": "hui"}
    
    In [6]: d = c
    
    In [7]: id(c), id(d)
    Out[7]: (2053851035112, 2053851035112)
    
        
    In [8]: a.append(44)
    
    In [9]: a
    Out[9]: [11, 22, 33, 44]
    
    In [10]: b
    Out[10]: [11, 22, 33, 44]
    
    In [11]: c["age"] = 21
    
    In [12]: c
    Out[12]: { 'name': 'hui', 'age': 21}
    
    In [13]: d
    Out[13]: { 'name': 'hui', 'age': 21}

可以看到当给一个变量直接赋值时，其实就是将对象引用复制了一份，所以 `id()` 取得内存地址都一样，它们指向的都是同一个对象。画张图就好理解。

![直接赋值][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70]

## 浅拷贝 ##

利用内置模块 `copy` 实现浅拷贝

In [12]: a = [1, 2]
    
    In [13]: b = [3, 4]
    
    In [14]: c = [a, b]
    
    In [15]: d = c
    
    In [16]: id(c),          id(d)
    Out[16]: (1409068540040, 1409068540040)
    
    In [17]: import copy
    
    In [18]: e = c.copy()
    
    In [19]: id(c),          id(d),         id(e)
    Out[19]: (1409068540040, 1409068540040, 1409070776520) 
    # 浅拷贝copy的对象id()不一样
    
    In [20]: id(c[0]), id(c[1])
    Out[20]: (1409071493512, 1409071679112)
    
    In [21]: id(e[0]), id(e[1])
    Out[21]: (1409071493512, 1409071679112)
    # 其子对象则一样
    
    In [22]: a.append(5)
    
    In [23]: b.append(6)
    
    In [24]: c
    Out[24]: [[1, 2, 5], [3, 4, 6]]
    
    In [25]: d
    Out[25]: [[1, 2, 5], [3, 4, 6]]
    
    In [26]: e
    Out[26]: [[1, 2, 5], [3, 4, 6]]
    # 内容一致
        
    In [28]: c.append(7)
    
    In [29]: c
    Out[29]: [[1, 2, 5], [3, 4, 6], 7]
    
    In [30]: e
    Out[30]: [[1, 2, 5], [3, 4, 6]]

可以看出直接赋值 `c` 和 `d` 是同一对象，而浅拷贝 `copy` 的 `c` 和 `e` 是一个分别独立的对象，但他们的子对象 `a` , `b` 还是 **指向统一对象即引用**。

因此当 `c.append(7)` 后，只有 `c` 对象改变了，而浅拷贝的 `e` 还是没有变化。

当 `a.append(5), b.append(6)` 后，`c, d, e` 对象依然内容一致。

![直接赋值与浅拷贝对比][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70 1]

## 深拷贝 ##

通过 `copy.deepcopy()` 来实现深拷贝

In [33]: a = [1, 2]
    
    In [34]: b = [3, 4]
    
    In [35]: c = [a, b]
    
    In [36]: d = copy.deepcopy(c)
    
    In [37]: id(c), id(d)
    Out[37]: (1409071919752, 1409071607112)
    
    In [38]: id(c[0]), id(c[1])
    Out[38]: (1409071948680, 1409071766216)
    
    In [39]: id(d[0]), id(d[1])
    Out[39]: (1409071976328, 1409071919880)
    # 完全拷贝了，其子对象的id()都不一样
    
    In [40]: c.append(5)
    
    In [41]: c
    Out[41]: [[1, 2], [3, 4], 5]
    
    In [42]: d
    Out[42]: [[1, 2], [3, 4]]
    
    In [43]: a.append(3)
    
    In [44]: b.append(5)
    
    In [45]: c
    Out[45]: [[1, 2, 3], [3, 4, 5], 5]
    
    In [46]: d
    Out[46]: [[1, 2], [3, 4]]
    # 因此任c怎么修改，都影响不到d
    
    In [47]: d[0].append(5)
    
    In [48]: d[1].append(6)
    
    In [49]: d
    Out[49]: [[1, 2, 5], [3, 4, 6]]
    
    In [50]: d.append(7)
    
    In [51]: d
    Out[51]: [[1, 2, 5], [3, 4, 6], 7]
    
    In [52]: c
    Out[52]: [[1, 2, 3], [3, 4, 5], 5]
    # d怎么修改也影响不到c

深度拷贝， 完全拷贝了父对象及其子对象，两者是完全独立的。因此 `c,d` 做任何操作都互不影响。

![深拷贝][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70 2]

## 三者对比 ##

*  `d = c` 赋值引用，`c` 和 `d` 都指向同一个对象
 *  `e = c.copy()` 浅拷贝，`c` 和 `e` 是一个 **独立的对象**，但他们的 **子对象还是指向统一对象即引用**。
 *  `f = copy.deepcopy(c)` 深度拷贝，`c` 和 `f` **完全拷贝了父对象及其子对象，两者是完全独立的**。

![深浅拷贝理解图1][1]

## 拷贝对可变类型和不可变类型的区别 ##

*  `copy.copy()` 对于可变类型，会进行浅拷贝。
 *  `copy.copy()` 对于不可变类型，不会拷贝，仅仅是指向。
 *  `copy.deepcopy()` 深拷贝对可变、不可变类型都一样递归拷贝所有，对象完全独立

**所谓的不可变指的是所指向的内存中的内容不可变。**

**同一份内存地址，其内容发生了改变，但地址依旧不变。说明是可变数据类型例如 `list, set, dict`**。

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>是否可变</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>整型</td> 
   <td>不可变</td> 
  </tr> 
  <tr> 
   <td>字符串 <code>str</code></td> 
   <td>不可变</td> 
  </tr> 
  <tr> 
   <td>元组 <code>tuple</code></td> 
   <td>不可变</td> 
  </tr> 
  <tr> 
   <td>列表 <code>list</code></td> 
   <td>可变</td> 
  </tr> 
  <tr> 
   <td>集合 <code>set</code></td> 
   <td>可变</td> 
  </tr> 
  <tr> 
   <td>字典 <code>dict</code></td> 
   <td>可变</td> 
  </tr> 
 </tbody> 
</table>

### 浅拷贝测试 ###

In [54]: # 可变类型list
    
    In [55]: a = [1, 2, 3]
    
    In [56]: b = copy.copy(a)
    
    In [57]: id(a)
    Out[57]: 1409069563528
    
    In [58]: id(b)
    Out[58]: 1409071719752
    
    In [59]: a.append(4)
    
    In [60]: a
    Out[60]: [1, 2, 3, 4]
    
    In [61]: b
    Out[61]: [1, 2, 3]
    
    In [63]: # 不可变类型 tuple
    
    In [64]: c = (1, 2, 3)
    
    In [65]: d = copy.copy(c)
    
    In [66]: id(c)
    Out[66]: 1409070834456
    
    In [67]: id(d)
    Out[67]: 1409070834456

当浅拷贝 `copy()` 不可变类型元组时 `tuple` ，`c, d`的内存地址都一样，说明仅是指向。

### 深拷贝测试 ###

In [71]: a = ([1, 2], [3, 4])
    
    In [72]: b = copy.copy(a)
    
    In [73]: c = copy.deepcopy(a)
    
    In [74]: id(a)
    Out[74]: 1409068519944
    
    In [75]: id(b)
    Out[75]: 1409068519944
    # 浅拷贝不可变类型id()一致
    
    In [76]: id(c)
    Out[76]: 1409071533448
    # 深拷贝不可变类型id()不一致
    
    In [77]: b[0].append(3)
    
    In [78]: b[1].append(5)
    
    In [79]: a
    Out[79]: ([1, 2, 3], [3, 4, 5])
    
    In [80]: b
    Out[80]: ([1, 2, 3], [3, 4, 5])
    
    In [81]: c
    Out[81]: ([1, 2], [3, 4])
    # 浅拷贝的子对象引用一致
    
    In [82]: c[0].append(3)
    
    In [83]: c
    Out[83]: ([1, 2, 3], [3, 4])
    
    In [84]: b
    Out[84]: ([1, 2, 3], [3, 4, 5])
    
    In [85]: a
    Out[85]: ([1, 2, 3], [3, 4, 5])
    # 深拷贝则是完全拷贝，互不影响

`copy.deepcopy()` 深拷贝对可变、不可变类型都一样递归拷贝所有，对象完全独立。

![深浅拷贝理解图2][2]

## 公众号 ##

**新建文件夹X**

> 大自然用数百亿年创造出我们现实世界，而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦，用大脑构建一切。人们把1000视为权威，我们反其道行之，捍卫1024的地位。我们不是键盘侠，我们只是平凡世界中不凡的缔造者 。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70]: /images/20221022/9e0ee91889994c3fbec83d95f8df3374.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70 1]: /images/20221022/4d317c2072314cfb9a6add71c4d57a1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3_size_16_color_FFFFFF_t_70 2]: /images/20221022/0f24e1d9f7c64f4e9c519ad89325a6d1.png
[1]: https://img-blog.csdnimg.cn/20210323232255600.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3,size_16,color_FFFFFF,t_70
[2]: https://img-blog.csdnimg.cn/20210323232101911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjI5ODU3,size_16,color_FFFFFF,t_70