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 的实现
首先,要说明几点:python 底层源码使用C语言实现在 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的过程主要分为两个步骤:
创建 PyListObject 结构体对 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 对象
原文地址:https://www.toutiao.com/article/7000980108211257892/
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。