解密Pythonlist深/浅拷贝原理

[[422995]]

1. python list的深/浅拷贝

python 有一种常用数据类型：list，使用list时经常需要考虑一件事件，那就是：浅拷贝与深拷贝。

成都创新互联作为成都网站建设公司，专注网站建设公司、网站设计，有关企业网站建设方案、改版、费用等问题，行业涉及酒店设计等多个领域，已为上千家企业服务，得到了客户的尊重与认可。

至于什么是深浅拷贝，先从一个示例代码来分析一下：

 
 
 
 
    
  
  
  
  
  1. import copy 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. # list 测试使用的源数据 
    4. 
  
  
  
  
  4. lists = [[1, 2, 3], 4, 5, 6] 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. def low_copy(): 
    7. 
  
  
  
  
  7.     # list 浅拷贝 
    8. 
  
  
  
  
  8.     low_list = copy.copy(lists) 
    9. 
  
  
  
  
  9.     return list(low_list) 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. def deep_copy(): 
    12. 
  
  
  
  
  12.     # list 深拷贝 
    13. 
  
  
  
  
  13.     deep_list = copy.deepcopy(lists) 
    14. 
  
  
  
  
  14.     return list(deep_list) 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16. if __name__ == "__main__": 
    17. 
  
  
  
  
  17.     print("源 list:", lists) 
    18. 
  
  
  
  
  18.     #  分别获取 浅拷贝、深拷贝 list对象 
    19. 
  
  
  
  
  19.     lists_c = low_copy() 
    20. 
  
  
  
  
  20.     lists_d = deep_copy() 
    21. 
  
  
  
  
  21.     print("浅拷贝 list:", lists_c) 
    22. 
  
  
  
  
  22.     print("深拷贝 list:", lists_c) 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.     print("========================") 
    25. 
  
  
  
  
  25.     # 对源数据的 第0下数据追加数值7 
    26. 
  
  
  
  
  26.     print("对源list的第0下数据追加数值7，start") 
    27. 
  
  
  
  
  27.     lists[0].append(7) 
    28. 
  
  
  
  
  28.     print("对源list的第0下数据追加数值7，end") 
    29. 
  
  
  
  
  29.     print("========================") 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.     # 源数据的 第0下数据追加数值7 之后验证，深浅拷贝数据的变化 
    32. 
  
  
  
  
  32.     print("源 list:", lists) 
    33. 
  
  
  
  
  33.     print("浅拷贝 list:", lists_c) 
    34. 
  
  
  
  
  34.     print("深拷贝 list:", lists_d) 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.     # 执行结果 
    37. 
  
  
  
  
  37.     #  
    38. 
  
  
  
  
  38.     # 源 list: [[1, 2, 3], 4, 5, 6] 
    39. 
  
  
  
  
  39.     # 浅拷贝 list: [[1, 2, 3], 4, 5, 6] 
    40. 
  
  
  
  
  40.     # 深拷贝 list: [[1, 2, 3], 4, 5, 6] 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.     # ======================== 
    43. 
  
  
  
  
  43.     # 对源list的第0下数据追加数值7，start 
    44. 
  
  
  
  
  44.     # 对源list的第0下数据追加数值7，end 
    45. 
  
  
  
  
  45.     # ======================== 
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47.     # 源 list: [[1, 2, 3, 7], 4, 5, 6] 
    48. 
  
  
  
  
  48.     # 浅拷贝 list: [[1, 2, 3, 7], 4, 5, 6] 
    49. 
  
  
  
  
  49.     # 深拷贝 list: [[1, 2, 3], 4, 5, 6] 
    50.

通过示例代码可以看出：在对list进行浅拷贝、深拷贝之后，对源数据进行修改，则会直接影响浅拷贝的数据，深拷贝的数据则无影响。

这说明了什么，具体又是怎么实现的呢?

2. pyhton list 的实现

首先，要说明几点：

  1. python 底层源码使用C语言实现
  2. 在 python 中一切皆对象(整数、字符串，甚至类型、函数等都是对象)

python的对象，大概分为以下几种：

参考 https://flaggo.github.io/python3-source-code-analysis/objects/object/

  • Fundamental 对象: 类型对象
  • Numeric 对象: 数值对象
  • Sequence 对象: 容纳其他对象的序列集合对象
  • Mapping 对象: 类似 C++中的 map 的关联对象
  • Internal 对象: Python 虚拟机在运行时内部使用的对象

3. list 对象

在python的源码实现中，list的结构体如下：

 
 
 
 
    
  
  
  
  
  1. // 源文件：Include/listobject.h 
    2. 
  
  
  
  
  2. // listobject.h 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. typedefstruct { 
    5. 
  
  
  
  
  5.     // 对象的公共头部 
    6. 
  
  
  
  
  6.     PyObject_VAR_HEAD 
    7. 
  
  
  
  
  7.      
    8. 
  
  
  
  
  8.     // 指向 list 元素的指针向量，list[0] 就是 ob_item[0] 
    9. 
  
  
  
  
  9.     // 可以看到 ob_item 是个二级指针 
    10. 
  
  
  
  
  10.     //   也就是说 **ob_item 表示它是指向 PyObject类型指针数组 指针 
    11. 
  
  
  
  
  11.     //      *ob_item 表示它是 PyObject类型指针数组 
    12. 
  
  
  
  
  12.     /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */ 
    13. 
  
  
  
  
  13.     PyObject **ob_item; 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.     /* ob_item contains space for 'allocated' elements.  The number 
    16. 
  
  
  
  
  16.      * currently in use is ob_size. 
    17. 
  
  
  
  
  17.      * Invariants: 
    18. 
  
  
  
  
  18.      *     0 <= ob_size <= allocated 
    19. 
  
  
  
  
  19.      *     len(list) == ob_size 
    20. 
  
  
  
  
  20.      *     ob_item == NULL implies ob_size == allocated == 0 
    21. 
  
  
  
  
  21.      * list.sort() temporarily sets allocated to -1 to detect mutations. 
    22. 
  
  
  
  
  22.      * 
    23. 
  
  
  
  
  23.      * Items must normally not be NULL, except during construction when 
    24. 
  
  
  
  
  24.      * the list is not yet visible outside the function that builds it. 
    25. 
  
  
  
  
  25.      */ 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.     // list 容纳元素的总数 
    28. 
  
  
  
  
  28.     Py_ssize_t allocated; 
    29. 
  
  
  
  
  29. } PyListObject; 
    30.

从 list 的结构体可以看出，真正存储对象的是 ob_item 字段，该字段是一个指向 指针数组 的指针，从而得知 PyListObject 结构体是一个多级结构体。

创建list的过程主要分为两个步骤：

  1. 创建 PyListObject 结构体
  2. 对 ob_item 指向的指针数组进行初始化操作
 
 
 
 
    
  
  
  
  
  1. // 源文件位置：Objects/listobject.c 
    2. 
  
  
  
  
  2. // 创建一个新的 list 
    3. 
  
  
  
  
  3. PyObject * 
    4. 
  
  
  
  
  4. PyList_New(Py_ssize_t size) { 
    5. 
  
  
  
  
  5.     // 判断创建 list 时的 size 是否合法 
    6. 
  
  
  
  
  6.     if (size < 0) { 
    7. 
  
  
  
  
  7.         PyErr_BadInternalCall(); 
    8. 
  
  
  
  
  8.         returnNULL; 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     struct _Py_list_state *state = get_list_state(); 
    12. 
  
  
  
  
  12.     // 最终创建的 list 对象指针 
    13. 
  
  
  
  
  13.     PyListObject *op; 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. #ifdef Py_DEBUG 
    16. 
  
  
  
  
  16.     // PyList_New() must not be called after _PyList_Fini() 
    17. 
  
  
  
  
  17.     assert(state->numfree != -1); 
    18. 
  
  
  
  
  18. #endif 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.     if (state->numfree) { 
    21. 
  
  
  
  
  21.         state->numfree--; 
    22. 
  
  
  
  
  22.         op = state->free_list[state->numfree]; 
    23. 
  
  
  
  
  23.         _Py_NewReference((PyObject *) op); 
    24. 
  
  
  
  
  24.     } else { 
    25. 
  
  
  
  
  25.         // 创建一个新的 list 
    26. 
  
  
  
  
  26.         op = PyObject_GC_New(PyListObject, &PyList_Type); 
    27. 
  
  
  
  
  27.         if (op == NULL) { 
    28. 
  
  
  
  
  28.             returnNULL; 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.     if (size <= 0) { 
    33. 
  
  
  
  
  33.         op->ob_item = NULL; 
    34. 
  
  
  
  
  34.     } else { 
    35. 
  
  
  
  
  35.         op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *)); 
    36. 
  
  
  
  
  36.         if (op->ob_item == NULL) { 
    37. 
  
  
  
  
  37.             Py_DECREF(op); 
    38. 
  
  
  
  
  38.             return PyErr_NoMemory(); 
    39. 
  
  
  
  
  39.         } 
    40. 
  
  
  
  
  40.     } 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.     Py_SET_SIZE(op, size); 
    43. 
  
  
  
  
  43.     op->allocated = size; 
    44. 
  
  
  
  
  44.     _PyObject_GC_TRACK(op); 
    45. 
  
  
  
  
  45.     return (PyObject *) op; 
    46. 
  
  
  
  
  46. } 
    47.

4. list 浅拷贝

 
 
 
 
    
  
  
  
  
  1. // 源文件位置：Objects/listobject.c 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. /*[clinic input] 
    4. 
  
  
  
  
  4. list.copy 
    5. 
  
  
  
  
  5. Return a shallow copy of the list. 
    6. 
  
  
  
  
  6. [clinic start generated code]*/ 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. // list 的 浅拷贝 
    9. 
  
  
  
  
  9. static PyObject * 
    10. 
  
  
  
  
  10. list_copy_impl(PyListObject *self) 
    11. 
  
  
  
  
  11. /*[clinic end generated code: output=ec6b72d6209d418e input=6453ab159e84771f]*/ 
    12. 
  
  
  
  
  12. { 
    13. 
  
  
  
  
  13.     return list_slice(self, 0, Py_SIZE(self)); 
    14. 
  
  
  
  
  14. } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. // ilow、ihigh 的类型 Py_ssize_t 为当前系统一个指针的大小 
    18. 
  
  
  
  
  18. static PyObject * 
    19. 
  
  
  
  
  19. list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh) { 
    20. 
  
  
  
  
  20.     PyListObject *np; 
    21. 
  
  
  
  
  21.     PyObject **src, **dest; 
    22. 
  
  
  
  
  22.     Py_ssize_t i, len; 
    23. 
  
  
  
  
  23.     len = ihigh - ilow; 
    24. 
  
  
  
  
  24.     if (len <= 0) { 
    25. 
  
  
  
  
  25.         return PyList_New(0); 
    26. 
  
  
  
  
  26.     } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.     // 生成新的 list 
    29. 
  
  
  
  
  29.     np = (PyListObject *) list_new_prealloc(len); 
    30. 
  
  
  
  
  30.     if (np == NULL) 
    31. 
  
  
  
  
  31.         returnNULL; 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.     // 从 list 的第一个位置开始 a->ob_item 偏移 ilow，即：移动到 第 ilow 个数值元素的指针位置 
    34. 
  
  
  
  
  34.     src = a->ob_item + ilow; 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.     // 新的 list 的 数值列表第一个位置 
    37. 
  
  
  
  
  37.     dest = np->ob_item; 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39.     // 进行复制，注意：只是复制了 对象的指针 
    40. 
  
  
  
  
  40.     for (i = 0; i < len; i++) { 
    41. 
  
  
  
  
  41.         // src[i] 存储着 指向具体的对象的指针 
    42. 
  
  
  
  
  42.         PyObject *v = src[i]; 
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.         // v 的引用计数 +1 
    45. 
  
  
  
  
  45.         Py_INCREF(v); 
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47.         // 复制到新的list中 
    48. 
  
  
  
  
  48.         // 此时 新老list底层数据对象指向相同 
    49. 
  
  
  
  
  49.         dest[i] = v; 
    50. 
  
  
  
  
  50.     } 
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52.     // 设置新list的size 
    53. 
  
  
  
  
  53.     // ob->ob_size = size 
    54. 
  
  
  
  
  54.     Py_SET_SIZE(np, len); 
    55. 
  
  
  
  
  55.     return (PyObject *) np; 
    56. 
  
  
  
  
  56. } 
    57.

 进行浅拷贝之后，从内存布局发生的变化，可以看出：新、老list共享底层数据对象，这也是导致一个list进行修改之后，影响其他list的原因。

5. list 深拷贝

进行深拷贝之后，从内存布局发生的变化，可以看出：新、老list分别使用不同的底层数据对象，这就不会导致一个list进行修改之后，影响其他list。

总结

通过分析python底层源码了解到list的底层结构以及深、浅拷贝原理，开发过程中使用深拷贝还是浅拷贝，则需要根据实际情况来处理。

  • 浅拷贝在拷贝时，只拷贝第一层中的引用，如果元素是可变对象，并且被修改，那么拷贝的对象也会发生变化。
  • 深拷贝在拷贝时，会逐层进行拷贝，直到所有的引用都是不可变对象为止。
  • Python 有多种方式实现浅拷贝，copy 模块的 copy 函数 ，对象的 copy 函数 ，工厂方法，切片等。
  • 大多数情况下，编写程序时，都是使用浅拷贝，除非有特定的需求。
  • 浅拷贝的优点：拷贝速度快，占用空间少，拷贝效率高。

本文名称：解密Pythonlist深/浅拷贝原理
链接URL：http://www.gawzjz.com/qtweb2/news31/4981.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

各行业网站

传美奇电气　　 　成都网站运维　　 　成都气球装饰　　 　成都雨棚定制　　 　普格博源建站　　 　专业网站设计　　 　网站域名　　 　成都小程序开发　　 　支点广告　　 　小谭建站　　 　商标注册　　 　成都做网站　　 　网站建设公司　　 　温江网站制作　　 　app开发　　 　攀枝花网站建设　　 　网站营销　　 　网络推广　　 　成都服务器租用　　 　名片设计