本网站(662p.com)打包出售,且带程序代码数据,662p.com域名,程序内核采用TP框架开发,需要联系扣扣:2360248666 /wx:lianweikj
精品域名一口价出售:1y1m.com(350元) ,6b7b.com(400元) , 5k5j.com(380元) , yayj.com(1800元), jiongzhun.com(1000元) , niuzen.com(2800元) , zennei.com(5000元)
需要联系扣扣:2360248666 /wx:lianweikj
解密Python list 深/浅拷贝原理
phpren · 606浏览 · 发布于2021-09-10 +关注

python 有一种常用数据类型:list,使用list时经常需要考虑一件事件,那就是:浅拷贝与深拷贝。至于什么是深浅拷贝,本篇就给大家分析一下。


1. python list的深/浅拷贝

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

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

import copy 

# list 测试使用的源数据 
lists = [[1, 2, 3], 4, 5, 6] 

def low_copy(): 
    # list 浅拷贝 
    low_list = copy.copy(lists) 
    return list(low_list) 

def deep_copy(): 
    # list 深拷贝 
    deep_list = copy.deepcopy(lists) 
    return list(deep_list) 

if __name__ == "__main__": 
    print("源 list:", lists) 
    #  分别获取 浅拷贝、深拷贝 list对象 
    lists_c = low_copy() 
    lists_d = deep_copy() 
    print("浅拷贝 list:", lists_c) 
    print("深拷贝 list:", lists_c) 

    print("========================") 
    # 对源数据的 第0下数据追加数值7 
    print("对源list的第0下数据追加数值7,start") 
    lists[0].append(7) 
    print("对源list的第0下数据追加数值7,end") 
    print("========================") 

    # 源数据的 第0下数据追加数值7 之后验证,深浅拷贝数据的变化 
    print("源 list:", lists) 
    print("浅拷贝 list:", lists_c) 
    print("深拷贝 list:", lists_d) 

    # 执行结果 
    #  
    # 源 list: [[1, 2, 3], 4, 5, 6] 
    # 浅拷贝 list: [[1, 2, 3], 4, 5, 6] 
    # 深拷贝 list: [[1, 2, 3], 4, 5, 6] 

    # ======================== 
    # 对源list的第0下数据追加数值7,start 
    # 对源list的第0下数据追加数值7,end 
    # ======================== 

    # 源 list: [[1, 2, 3, 7], 4, 5, 6] 
    # 浅拷贝 list: [[1, 2, 3, 7], 4, 5, 6] 
    # 深拷贝 list: [[1, 2, 3], 4, 5, 6]

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

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

    2. pyhton list 的实现

    首先,要说明几点:


    1. python 底层源码使用C语言实现


    2. 在 python 中一切皆对象(整数、字符串,甚至类型、函数等都是对象)

    python的对象,大概分为以下几种:

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

    解密 python list 深/浅拷贝 原理

    • Fundamental 对象: 类型对象

    • Numeric 对象: 数值对象

    • Sequence 对象: 容纳其他对象的序列集合对象

    • Mapping 对象: 类似 C++中的 map 的关联对象

    • Internal 对象: Python 虚拟机在运行时内部使用的对象

     

    3. list 对象

    在python的源码实现中,list的结构体如下:

    // 源文件:Include/listobject.h 
    // listobject.h 
    
    typedefstruct { 
        // 对象的公共头部 
        PyObject_VAR_HEAD 
         
        // 指向 list 元素的指针向量,list[0] 就是 ob_item[0] 
        // 可以看到 ob_item 是个二级指针 
        //   也就是说 **ob_item 表示它是指向 PyObject类型指针数组 指针 
        //      *ob_item 表示它是 PyObject类型指针数组 
        /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */ 
        PyObject **ob_item; 
    
        /* ob_item contains space for 'allocated' elements.  The number 
         * currently in use is ob_size. 
         * Invariants: 
         *     0 <= ob_size <= allocated 
         *     len(list) == ob_size 
         *     ob_item == NULL implies ob_size == allocated == 0 
         * list.sort() temporarily sets allocated to -1 to detect mutations. 
         * 
         * Items must normally not be NULL, except during construction when 
         * the list is not yet visible outside the function that builds it. 
         */ 
    
        // list 容纳元素的总数 
        Py_ssize_t allocated; 
    } PyListObject;

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

      解密 python list 深/浅拷贝 原理

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


      1. 创建 PyListObject 结构体


      2. 对 ob_item 指向的指针数组进行初始化操作

      // 源文件位置:Objects/listobject.c 
      // 创建一个新的 list 
      PyObject * 
      PyList_New(Py_ssize_t size) { 
          // 判断创建 list 时的 size 是否合法 
          if (size < 0) { 
              PyErr_BadInternalCall(); 
              returnNULL; 
          } 
      
          struct _Py_list_state *state = get_list_state(); 
          // 最终创建的 list 对象指针 
          PyListObject *op; 
      
      #ifdef Py_DEBUG 
          // PyList_New() must not be called after _PyList_Fini() 
          assert(state->numfree != -1); 
      #endif 
      
          if (state->numfree) { 
              state->numfree--; 
              op = state->free_list[state->numfree]; 
              _Py_NewReference((PyObject *) op); 
          } else { 
              // 创建一个新的 list 
              op = PyObject_GC_New(PyListObject, &PyList_Type); 
              if (op == NULL) { 
                  returnNULL; 
              } 
          } 
      
          if (size <= 0) { 
              op->ob_item = NULL; 
          } else { 
              op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *)); 
              if (op->ob_item == NULL) { 
                  Py_DECREF(op); 
                  return PyErr_NoMemory(); 
              } 
          } 
      
          Py_SET_SIZE(op, size); 
          op->allocated = size; 
          _PyObject_GC_TRACK(op); 
          return (PyObject *) op; 
      }

        4. list 浅拷贝

        // 源文件位置:Objects/listobject.c 
        
        /*[clinic input] 
        list.copy 
        Return a shallow copy of the list. 
        [clinic start generated code]*/ 
        
        // list 的 浅拷贝 
        static PyObject * 
        list_copy_impl(PyListObject *self) 
        /*[clinic end generated code: output=ec6b72d6209d418e input=6453ab159e84771f]*/ 
        { 
            return list_slice(self, 0, Py_SIZE(self)); 
        } 
        
        
        // ilow、ihigh 的类型 Py_ssize_t 为当前系统一个指针的大小 
        static PyObject * 
        list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh) { 
            PyListObject *np; 
            PyObject **src, **dest; 
            Py_ssize_t i, len; 
            len = ihigh - ilow; 
            if (len <= 0) { 
                return PyList_New(0); 
            } 
        
            // 生成新的 list 
            np = (PyListObject *) list_new_prealloc(len); 
            if (np == NULL) 
                returnNULL; 
        
            // 从 list 的第一个位置开始 a->ob_item 偏移 ilow,即:移动到 第 ilow 个数值元素的指针位置 
            src = a->ob_item + ilow; 
        
            // 新的 list 的 数值列表第一个位置 
            dest = np->ob_item; 
        
            // 进行复制,注意:只是复制了 对象的指针 
            for (i = 0; i < len; i++) { 
                // src[i] 存储着 指向具体的对象的指针 
                PyObject *v = src[i]; 
        
                // v 的引用计数 +1 
                Py_INCREF(v); 
        
                // 复制到新的list中 
                // 此时 新老list底层数据对象指向相同 
                dest[i] = v; 
            } 
        
            // 设置新list的size 
            // ob->ob_size = size 
            Py_SET_SIZE(np, len); 
            return (PyObject *) np; 
        }


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

          解密 python list 深/浅拷贝 原理

          5. list 深拷贝

          解密 python list 深/浅拷贝 原理

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

          总结

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

          • 浅拷贝在拷贝时,只拷贝第一层中的引用,如果元素是可变对象,并且被修改,那么拷贝的对象也会发生变化。

          • 深拷贝在拷贝时,会逐层进行拷贝,直到所有的引用都是不可变对象为止。

          • Python 有多种方式实现浅拷贝,copy 模块的 copy 函数 ,对象的 copy 函数 ,工厂方法,切片等。

          • 大多数情况下,编写程序时,都是使用浅拷贝,除非有特定的需求。

          • 浅拷贝的优点:拷贝速度快,占用空间少,拷贝效率高。


          相关推荐

          PHP实现部分字符隐藏

          沙雕mars · 1312浏览 · 2019-04-28 09:47:56
          Java中ArrayList和LinkedList区别

          kenrry1992 · 896浏览 · 2019-05-08 21:14:54
          Tomcat 下载及安装配置

          manongba · 957浏览 · 2019-05-13 21:03:56
          JAVA变量介绍

          manongba · 953浏览 · 2019-05-13 21:05:52
          什么是SpringBoot

          iamitnan · 1077浏览 · 2019-05-14 22:20:36
          加载中

          0评论

          评论
          我从小喜欢编程,一直在学习中,从未停止,未来也是如此!
          小鸟云服务器
          扫码进入手机网页