关于python:深入理解-Python-的对象拷贝和内存布局

1次阅读

共计 8311 个字符，预计需要花费 21 分钟才能阅读完成。

在本篇文章当中次要给大家介绍 python 当中的拷贝问题，话不多说咱们间接看代码，你晓得上面一些程序片段的输入后果吗？

a = [1, 2, 3, 4]
b = a
print(f"{a =} \t|\t {b =}")
a[0] = 100
print(f"{a =} \t|\t {b =}")

a = [1, 2, 3, 4]
b = a.copy()
print(f"{a =} \t|\t {b =}")
a[0] = 100
print(f"{a =} \t|\t {b =}")

a = [[1, 2, 3], 2, 3, 4]
b = a.copy()
print(f"{a =} \t|\t {b =}")
a[0][0] = 100
print(f"{a =} \t|\t {b =}")

a = [[1, 2, 3], 2, 3, 4]
b = copy.copy(a)
print(f"{a =} \t|\t {b =}")
a[0][0] = 100
print(f"{a =} \t|\t {b =}")

a = [[1, 2, 3], 2, 3, 4]
b = copy.deepcopy(a)
print(f"{a =} \t|\t {b =}")
a[0][0] = 100
print(f"{a =} \t|\t {b =}")

在本篇文章当中咱们将对下面的程序进行具体的剖析。

首先咱们介绍一下一个比拟好用的对于数据在内存上的逻辑散布的网站，https://pythontutor.com/visua…

咱们在这个网站上运行第一份代码：

从下面的输入后果来看 a 和 b 指向的是同一个内存当中的数据对象。因而第一份代码的输入后果是雷同的。咱们应该如何确定一个对象的内存地址呢？在 Python 当中给咱们提供了一个内嵌函数 id() 用于失去一个对象的内存地址：

a = [1, 2, 3, 4]
b = a
print(f"{a =} \t|\t {b =}")
a[0] = 100
print(f"{a =} \t|\t {b =}")
print(f"{id(a) = } \t|\t {id(b) = }")
# 输入后果
# a = [1, 2, 3, 4]     |     b = [1, 2, 3, 4]
# a = [100, 2, 3, 4]     |     b = [100, 2, 3, 4]
# id(a) = 4393578112     |     id(b) = 4393578112

事实上下面的对象内存布局是有一点问题的，或者说是不够精确的，然而也是可能示意出各个对象之间的关系的，咱们当初来深刻理解一下。在 Cpython 里你能够认为每一个变量都能够认为是一个指针，指向被示意的那个数据，这个指针保留的就是这个 Python 对象的内存地址。

在 Python 当中，实际上列表保留的指向各个 Python 对象的指针，而不是理论的数据，因而下面的一小段代码，能够用如下的图示意对象在内存当中的布局：

变量 a 指向内存当中的列表 [1, 2, 3, 4]，列表当中有 4 个数据，这四个数据都是指针，而这四个指针指向内存当中 1，2，3，4 这四个数据。可能你会有疑难，这不是有问题吗？都是整型数据为什么不间接在列表当中寄存整型数据，为啥还要加一个指针，再指向这个数据呢？

事实上在 Python 当中，列表当中可能寄存任何 Python 对象，比方上面的程序是非法的：

data = [1, {1:2, 3:4}, {'a', 1, 2, 25.0}, (1, 2, 3), "hello world"]

在下面的列表当中第一个到最初一个数据的数据类型为：整型数据，字典，汇合，元祖，字符串，当初来看为了实现 Python 的这个个性，指针的个性是不是符合要求呢？每个指针所占用的内存是一样的，因而能够应用一个数组去存储 Python 对象的指针，而后再将这个指针指向真正的 Python 对象！

在通过下面的剖析之后，咱们来看一下上面的代码，他的内存布局是什么状况：

data = [[1, 2, 3], 4, 5, 6]
data_assign = data
data_copy = data.copy()

data_assign = data，对于这个赋值语句的内存布局咱们在之前曾经谈到过了，不过咱们也在温习一下，这个赋值语句的含意就是 data_assign 和 data 指向的数据是同一个数据，也就是同一个列表。
data_copy = data.copy()，这条赋值语句的含意是将 data 指向的数据进行浅拷贝，而后让 data_copy 指向拷贝之后的数据，这里的浅拷贝的意思就是，对列表当中的每一个指针进行拷贝，而不对列表当中指针指向的数据进行拷贝。从下面的对象的内存布局图咱们能够看到 data_copy 指向一个新的列表，然而列表当中的指针指向的数据和 data 列表当中的指针指向的数据是一样的，其中 data_copy 应用绿色的箭头进行示意，data 应用彩色的箭头进行示意。

在后面的文章当中咱们次要剖析了一下对象的内存布局，在本大节咱们应用 python 给咱们提供一个十分无效的工具去验证这一点。在 python 当中咱们能够应用 id() 去查看对象的内存地址，id(a) 就是查看对象 a 所指向的对象的内存地址。

看上面的程序的输入后果：

a = [1, 2, 3]
b = a
print(f"{id(a) = } {id(b) = }")
for i in range(len(a)):
    print(f"{i =} {id(a[i]) = } {id(b[i]) = }")

依据咱们之前的剖析，a 和 b 指向的同一块内存，也就说两个变量指向的是同一个 Python 对象，因而下面的多有输入的 id 后果 a 和 b 都是雷同的，下面的输入后果如下：

id(a) = 4392953984 id(b) = 4392953984
i = 0 id(a[i]) = 4312613104 id(b[i]) = 4312613104
i = 1 id(a[i]) = 4312613136 id(b[i]) = 4312613136
i = 2 id(a[i]) = 4312613168 id(b[i]) = 4312613168

看一下浅拷贝的内存地址：

a = [[1, 2, 3], 4, 5]
b = a.copy()
print(f"{id(a) = } {id(b) = }")
for i in range(len(a)):
    print(f"{i =} {id(a[i]) = } {id(b[i]) = }")

依据咱们在后面的剖析，调用列表自身的 copy 办法是对列表进行浅拷贝，只拷贝列表的指针数据，并不拷贝列表当中指针指向的真正的数据，因而如果咱们对列表当中的数据进行遍历失去指向的对象的地址的话，列表 a 和列表 b 返回的后果是一样的，然而和上一个例子不同的是 a 和 b 指向的列表的自身的地址是不一样的（因为进行了数据拷贝，能够参照上面浅拷贝的后果进行了解）。

能够联合上面的输入后果和下面的文字进行了解：

id(a) = 4392953984 id(b) = 4393050112 # 两个对象的输入后果不相等
i = 0 id(a[i]) = 4393045632 id(b[i]) = 4393045632 # 指向的是同一个内存对象因而内存地址相等 下同
i = 1 id(a[i]) = 4312613200 id(b[i]) = 4312613200
i = 2 id(a[i]) = 4312613232 id(b[i]) = 4312613232

在 python 外面有一个自带的包 copy，次要是用于对象的拷贝，在这个模块当中次要有两个办法 copy.copy(x) 和 copy.deepcopy()。

copy.copy(x) 办法次要是用于浅拷贝，这个办法的含意对于列表来说和列表自身的 x.copy() 办法的意义是一样的，都是进行浅拷贝。这个办法会结构一个新的 python 对象并且会将对象 x 当中所有的数据援用（指针）拷贝一份。
copy.deepcopy(x) 这个办法次要是对对象 x 进行深拷贝，这里的深拷贝的含意是会结构一个新的对象，会递归的查看对象 x 当中的每一个对象，如果递归查看的对象是一个不可变对象将不会进行拷贝，如果查看到的对象是可变对象的话，将从新开拓一块内存空间，将原来的在对象 x 当中的数据拷贝的新的内存当中。（对于可变和不可变对象咱们将在下一个大节仔细分析）
依据下面的剖析咱们能够晓得深拷贝的破费是比浅拷贝多的，尤其是当一个对象当中有很多子对象的时候，会破费很多工夫和内存空间。
对于 python 对象来说进行深拷贝和浅拷贝的区别次要在于复合对象（对象当中有子对象，比如说列表，元祖、类的实例等等）。这一点次要是和下一大节的可变和不可变对象有关系。

在 python 当中次要有两大类对象，可变对象和不可变对象，所谓可变对象就是对象的内容能够产生扭转，不可变对象就是对象的内容不可能产生扭转。

可变对象：比如说列表 (list)，字典 (dict)，汇合 (set)，字节数组 (bytearray)，类的实例对象。
不可变对象：整型 (int)，浮点型 (float)，复数 (complex)，字符串，元祖 (tuple)，不可变汇合 (frozenset)，字节 (bytes)。

看到这里你可能会有疑难了，整数和字符串不是能够批改吗？

a = 10
a = 100
a = "hello"
a = "world"

比方上面的代码是正确的，并不会产生谬误，然而事实上其实 a 指向的对象是产生了变动的，第一个对象指向整型或者字符串的时候，如果从新赋一个新的不同的整数或者字符串对象的话，python 会创立一个新的对象，咱们能够应用上面的代码进行验证：

a = 10
print(f"{id(a) = }")
a = 100
print(f"{id(a) = }")
a = "hello"
print(f"{id(a) = }")
a = "world"
print(f"{id(a) = }")

下面的程序的输入后果如下所示：

id(a) = 4365566480
id(a) = 4365569360
id(a) = 4424109232
id(a) = 4616350128

能够看到的是当从新赋值之后变量指向的内存对象是产生了变动的（因为内存地址产生了变动），这就是不可变对象，尽管能够对变量从新赋值，然而失去的是一个新对象并不是在原来的对象上进行批改的！

咱们当初来看一下可变对象列表产生批改之后内存地址是怎么发生变化的：

data = []
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")

下面的代码输入后果如下所示：

id(data) = 4614905664
id(data) = 4614905664
id(data) = 4614905664
id(data) = 4614905664
id(data) = 4614905664

从下面的输入后果来看能够晓得，当咱们往列表当中退出新的数据之后（批改了列表），列表自身的地址并没有发生变化，这就是可变对象。

咱们在后面谈到了深拷贝和浅拷贝，咱们当初来剖析一下上面的代码：

data = [1, 2, 3]
data_copy = copy.copy(data)
data_deep = copy.deepcopy(data)
print(f"{id(data) = } | {id(data_copy) = } | {id(data_deep) = }")
print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")

下面的代码输入后果如下所示：

id(data) = 4620333952 | id(data_copy) = 4619860736 | id(data_deep) = 4621137024
id(data[0]) = 4365566192 | id(data_copy[0]) = 4365566192 | id(data_deep[0]) = 4365566192
id(data[1]) = 4365566224 | id(data_copy[1]) = 4365566224 | id(data_deep[1]) = 4365566224
id(data[2]) = 4365566256 | id(data_copy[2]) = 4365566256 | id(data_deep[2]) = 4365566256

看到这里你必定会十分纳闷，为什么深拷贝和浅拷贝指向的内存对象是一样的呢？前列咱们能够了解，因为浅拷贝拷贝的是援用，因而他们指向的对象是同一个，然而为什么深拷贝之后指向的内存对象和浅拷贝也是一样的呢？这正是因为列表当中的数据是整型数据，他是一个不可变对象，如果对 data 或者 data_copy 指向的对象进行批改，那么将会指向一个新的对象并不会间接批改原来的对象，因而对于不可变对象其实是不必开拓一块新的内存空间在从新赋值的，因为这块内存中的对象是不会产生扭转的。

咱们在来看一个可拷贝的对象：

data = [[1], [2], [3]]
data_copy = copy.copy(data)
data_deep = copy.deepcopy(data)
print(f"{id(data) = } | {id(data_copy) = } | {id(data_deep) = }")
print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")

下面的代码输入后果如下所示：

id(data) = 4619403712 | id(data_copy) = 4617239424 | id(data_deep) = 4620032640
id(data[0]) = 4620112640 | id(data_copy[0]) = 4620112640 | id(data_deep[0]) = 4620333952
id(data[1]) = 4619848128 | id(data_copy[1]) = 4619848128 | id(data_deep[1]) = 4621272448
id(data[2]) = 4620473280 | id(data_copy[2]) = 4620473280 | id(data_deep[2]) = 4621275840

从下面程序的输入后果咱们能够看到，当列表当中保留的是一个可变对象的时候，如果咱们进行深拷贝将创立一个全新的对象（深拷贝的对象内存地址和浅拷贝的不一样）。

通过下面的学习对于在本篇文章结尾提出的问题对于你来说应该是很简略的，咱们当初来剖析一下这几个代码片段：

a = [1, 2, 3, 4]
b = a
print(f"{a =} \t|\t {b =}")
a[0] = 100
print(f"{a =} \t|\t {b =}")

这个很简略啦，a 和 b 不同的变量指向同一个列表，a 两头的数据发生变化，那么 b 的数据也会发生变化，输入后果如下所示：

a = [1, 2, 3, 4]     |     b = [1, 2, 3, 4]
a = [100, 2, 3, 4]     |     b = [100, 2, 3, 4]
id(a) = 4614458816     |     id(b) = 4614458816

咱们再来看一下第二个代码片段

a = [1, 2, 3, 4]
b = a.copy()
print(f"{a =} \t|\t {b =}")
a[0] = 100
print(f"{a =} \t|\t {b =}")

因为 b 是 a 的一个浅拷贝，所以 a 和 b 指向的是不同的列表，然而列表当中数据的指向是雷同的，然而因为整型数据是不可变数据，当 a[0] 发生变化的时候，并不会批改原来的数据，而是会在内存当中创立一个新的整型数据，因而列表 b 的内容并不会发生变化。因而下面的代码输入后果如下所示：

a = [1, 2, 3, 4]     |     b = [1, 2, 3, 4]
a = [100, 2, 3, 4]     |     b = [1, 2, 3, 4]

再来看一下第三个片段：

a = [[1, 2, 3], 2, 3, 4]
b = a.copy()
print(f"{a =} \t|\t {b =}")
a[0][0] = 100
print(f"{a =} \t|\t {b =}")

这个和第二个片段的剖析是类似的，然而 a[0] 是一个可变对象，因而进行数据批改的时候，a[0] 的指向没有发生变化，因而 a 批改的内容会影响 b。

a = [[1, 2, 3], 2, 3, 4]     |     b = [[1, 2, 3], 2, 3, 4]
a = [[100, 2, 3], 2, 3, 4]     |     b = [[100, 2, 3], 2, 3, 4]

最初一个片段：

a = [[1, 2, 3], 2, 3, 4]
b = copy.deepcopy(a)
print(f"{a =} \t|\t {b =}")
a[0][0] = 100
print(f"{a =} \t|\t {b =}")

深拷贝会在内存当中从新创立一个和 a[0] 雷同的对象，并且让 b[0] 指向这个对象，因而批改 a[0]，并不会影响 b[0]，因而输入后果如下所示：

a = [[1, 2, 3], 2, 3, 4]     |     b = [[1, 2, 3], 2, 3, 4]
a = [[100, 2, 3], 2, 3, 4]     |     b = [[1, 2, 3], 2, 3, 4]

咱们当初简要看一下 Cpython 是如何实现 list 数据结构的，在 list 当中到底定义了一些什么货色：

typedef struct {
    PyObject_VAR_HEAD
    /* 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.
     */
    Py_ssize_t allocated;
} PyListObject;

在下面定义的构造体当中：

allocated 示意调配的内存空间的数量，也就是可能存储指针的数量，当所有的空间用完之后须要再次申请内存空间。
ob_item 指向内存当中真正存储指向 python 对象指针的数组，比如说咱们想得到列表当中第一个对象的指针的话就是 list->ob_item[0]，如果要失去真正的数据的话就是 *(list->ob_item[0])。
PyObject_VAR_HEAD 是一个宏，会在构造体当中定一个子结构体，这个子结构题的定义如下：

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

这里咱们不去谈对象 PyObject 了，次要说一下 ob_size，他示意列表当中存储了多少个数据，这个和 allocated 不一样，allocated 示意 ob_item 指向的数组一共有多少个空间，ob_size 示意这个数组存储了多少个数据 ob_size <= allocated。

在理解列表的构造体之后咱们当初应该可能了解之前的内存布局了，所有的列表并不存储真正的数据而是存储指向这些数据的指针。

在本篇文章当中次要给大家介绍了 python 当中对象的拷贝和内存布局，以及对对象内存地址的验证，最初略微介绍了一下 cpython 外部实现列表的构造体，帮忙大家深刻了解列表对象的内存布局。

以上就是本篇文章的所有内容了，我是 LeHung，咱们下期再见！！！更多精彩内容合集可拜访我的项目：https://github.com/Chang-LeHu…

关注公众号： 一无是处的钻研僧 ，理解更多计算机（Java、Python、计算机系统根底、算法与数据结构）常识。

正文完

python

发表至： python

2022-12-16

0

关于python:图灵Python高薪架构就业班零基础开发机器人应用项目班风掣红旗冻不翻

关于python:程序员减脂神仙吃法分享

关于python:pyav-是如何调用-FFmpeg-libraries-的

关于python:Centos配置IP地址

关于数据:全面便捷的数据管理能力助力数据运营降本增效

关于python:深入理解-Python-的对象拷贝和内存布局

深刻了解 Python 的对象拷贝和内存布局

前言

Python 对象的内存布局

牛刀小试

查看对象的内存地址

copy 模块

可变和不可变对象与对象拷贝

代码片段剖析

撕开 Python 对象的神秘面纱

总结

站内搜索