[[422995]]

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/

• 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 結構體是一個多級結構體。

創建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的原因。

5. list 深拷貝

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

總結

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

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