[[422995]]

1. python list的深/淺拷貝

python 有一種常用數據類型：list，使用list時經常需要考慮一件事件，那就是：淺拷貝與深拷貝。

成都創(chuàng)新互聯(lián)作為成都網站建設公司，專注網站建設公司、網站設計，有關企業(yè)網站建設方案、改版、費用等問題，行業(yè)涉及酒店設計等多個領域，已為上千家企業(yè)服務，得到了客戶的尊重與認可。

至于什么是深淺拷貝，先從一個示例代碼來分析一下：

 
 
 
 

  
  
  
  
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) 
  
  
  
  
 
  
  
  
  
    # 執(zhí)行結果 
  
  
  
  
    #  
  
  
  
  
    # 源 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進行淺拷貝、深拷貝之后，對源數據進行修改，則會直接影響淺拷貝的數據，深拷貝的數據則無影響。

這說明了什么，具體又是怎么實現(xiàn)的呢?

2. pyhton list 的實現(xiàn)

首先，要說明幾點：

1. python 底層源碼使用C語言實現(xiàn)
2. 在 python 中一切皆對象(整數、字符串，甚至類型、函數等都是對象)

python的對象，大概分為以下幾種：

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

• Fundamental 對象: 類型對象
• Numeric 對象: 數值對象
• Sequence 對象: 容納其他對象的序列集合對象
• Mapping 對象: 類似 C++中的 map 的關聯(lián)對象
• Internal 對象: Python 虛擬機在運行時內部使用的對象

3. list 對象

在python的源碼實現(xiàn)中，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 結構體是一個多級結構體。

創(chuàng)建list的過程主要分為兩個步驟：

1. 創(chuàng)建 PyListObject 結構體
2. 對 ob_item 指向的指針數組進行初始化操作

 
 
 
 

  
  
  
  
// 源文件位置：Objects/listobject.c 
  
  
  
  
// 創(chuàng)建一個新的 list 
  
  
  
  
PyObject * 
  
  
  
  
PyList_New(Py_ssize_t size) { 
  
  
  
  
    // 判斷創(chuàng)建 list 時的 size 是否合法 
  
  
  
  
    if (size < 0) { 
  
  
  
  
        PyErr_BadInternalCall(); 
  
  
  
  
        returnNULL; 
  
  
  
  
    } 
  
  
  
  
 
  
  
  
  
    struct _Py_list_state *state = get_list_state(); 
  
  
  
  
    // 最終創(chuàng)建的 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 { 
  
  
  
  
        // 創(chuàng)建一個新的 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 為當前系統(tǒng)一個指針的大小 
  
  
  
  
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; 
  
  
  
  
} 
 
 
 
 

 進行淺拷貝之后，從內存布局發(fā)生的變化，可以看出：新、老list共享底層數據對象，這也是導致一個list進行修改之后，影響其他list的原因。

5. list 深拷貝

進行深拷貝之后，從內存布局發(fā)生的變化，可以看出：新、老list分別使用不同的底層數據對象，這就不會導致一個list進行修改之后，影響其他list。

總結

通過分析python底層源碼了解到list的底層結構以及深、淺拷貝原理，開發(fā)過程中使用深拷貝還是淺拷貝，則需要根據實際情況來處理。

• 淺拷貝在拷貝時，只拷貝第一層中的引用，如果元素是可變對象，并且被修改，那么拷貝的對象也會發(fā)生變化。
• 深拷貝在拷貝時，會逐層進行拷貝，直到所有的引用都是不可變對象為止。
• Python 有多種方式實現(xiàn)淺拷貝，copy 模塊的 copy 函數 ，對象的 copy 函數 ，工廠方法，切片等。
• 大多數情況下，編寫程序時，都是使用淺拷貝，除非有特定的需求。
• 淺拷貝的優(yōu)點：拷貝速度快，占用空間少，拷貝效率高。

當前標題：解密Pythonlist深/淺拷貝原理
本文URL：http://uogjgqi.cn/article/dpsoppd.html