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 函数 ，工厂方法，切片等。
• 大多数情况下，编写程序时，都是使用浅拷贝，除非有特定的需求。
• 浅拷贝的优点：拷贝速度快，占用空间少，拷贝效率高。

扩展阅读

[1] https://blog.csdn.net/mall_lucy/article/details/104531218 图解深浅拷贝

[2] https://flaggo.github.io/python3-source-code-analysis/objects/list-object/ python list 对象