我的编程空间,编程开发者的网络收藏夹
学习永远不晚

Python的对象拷贝和内存布局如何实现

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

Python的对象拷贝和内存布局如何实现

今天小编给大家分享一下Python的对象拷贝和内存布局如何实现的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。

    前言

    你知道下面一些程序片段的输出结果吗?

    a = [1, 2, 3, 4]b = aprint(f"{a = } \t|\t {b = }")a[0] = 100print(f"{a = } \t|\t {b = }")
    a = [1, 2, 3, 4]b = a.copy()print(f"{a = } \t|\t {b = }")a[0] = 100print(f"{a = } \t|\t {b = }")
    a = [[1, 2, 3], 2, 3, 4]b = a.copy()print(f"{a = } \t|\t {b = }")a[0][0] = 100print(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] = 100print(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] = 100print(f"{a = } \t|\t {b = }")

    Python 对象的内存布局

    在 python 当中我们应该如何确定一个对象的内存地址呢?在 Python 当中给我们提供了一个内嵌函数 id() 用于得到一个对象的内存地址:

    a = [1, 2, 3, 4]b = aprint(f"{a = } \t|\t {b = }")a[0] = 100print(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 对象的指针,而不是实际的数据,因此上面的一小段代码,可以用如下的图表示对象在内存当中的布局:

    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 = datadata_copy = data.copy()

    Python的对象拷贝和内存布局如何实现

    Python的对象拷贝和内存布局如何实现

    • 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 = aprint(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 指向的列表的本身的地址是不一样的(因为进行了数据拷贝,可以参照下面浅拷贝的结果进行理解)。

    Python的对象拷贝和内存布局如何实现

    可以结合下面的输出结果和上面的文字进行理解:

    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]) = 4312613200i = 2 id(a[i]) = 4312613232 id(b[i]) = 4312613232

    copy模块

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

    copy.copy(x) 方法主要是用于浅拷贝,这个方法的含义对于列表来说和列表本身的 x.copy() 方法的意义是一样的,都是进行浅拷贝。这个方法会构造一个新的 python 对象并且会将对象 x 当中所有的数据引用(指针)拷贝一份。

    Python的对象拷贝和内存布局如何实现

    copy.deepcopy(x)  这个方法主要是对对象 x 进行深拷贝,这里的深拷贝的含义是会构造一个新的对象,会递归的查看对象 x 当中的每一个对象,如果递归查看的对象是一个不可变对象将不会进行拷贝,如果查看到的对象是可变对象的话,将重新开辟一块内存空间,将原来的在对象 x 当中的数据拷贝的新的内存当中。(关于可变和不可变对象我们将在下一个小节仔细分析)

    根据上面的分析我们可以知道深拷贝的花费是比浅拷贝多的,尤其是当一个对象当中有很多子对象的时候,会花费很多时间和内存空间。

    对于 python 对象来说进行深拷贝和浅拷贝的区别主要在于复合对象(对象当中有子对象,比如说列表,元祖、类的实例等等)。这一点主要是和下一小节的可变和不可变对象有关系。

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

    在 python 当中主要有两大类对象,可变对象和不可变对象,所谓可变对象就是对象的内容可以发生改变,不可变对象就是对象的内容不能够发生改变。

    • 可变对象:比如说列表(list),字典(dict),集合(set),字节数组(bytearray),类的实例对象。

    • 不可变对象:整型(int),浮点型(float),复数(complex),字符串,元祖(tuple),不可变集合(frozenset),字节(bytes)。

    看到这里你可能会有疑问了,整数和字符串不是可以修改吗?

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

    比如下面的代码是正确的,并不会发生错误,但是事实上其实 a 指向的对象是发生了变化的,第一个对象指向整型或者字符串的时候,如果重新赋一个新的不同的整数或者字符串对象的话,python 会创建一个新的对象,我们可以使用下面的代码进行验证:

    a = 10print(f"{id(a) = }")a = 100print(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 = aprint(f"{a = } \t|\t {b = }")a[0] = 100print(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] = 100print(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] = 100print(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] = 100print(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]

    撕开 Python 对象的神秘面纱

    我们现在简要看一下 Cpython 是如何实现 list 数据结构的,在 list 当中到底定义了一些什么东西:

    typedef struct {    PyObject_VAR_HEAD        PyObject **ob_item;        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; } PyVarObject;

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

    在了解列表的结构体之后我们现在应该能够理解之前的内存布局了,所有的列表并不存储真正的数据而是存储指向这些数据的指针。

    以上就是“Python的对象拷贝和内存布局如何实现”这篇文章的所有内容,感谢各位的阅读!相信大家阅读完这篇文章都有很大的收获,小编每天都会为大家更新不同的知识,如果还想学习更多的知识,请关注编程网行业资讯频道。

    免责声明:

    ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

    ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

    Python的对象拷贝和内存布局如何实现

    下载Word文档到电脑,方便收藏和打印~

    下载Word文档

    猜你喜欢

    Python的对象拷贝和内存布局如何实现

    今天小编给大家分享一下Python的对象拷贝和内存布局如何实现的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。前言你知道下面一
    2023-07-06

    浅析Python的对象拷贝和内存布局

    这篇文章主要为大家详细介绍了Python中的对象拷贝和内存布局的相关知识,文中的示例代码讲解详细,对我们学习Python有一定的帮助,需要的可以参考一下
    2022-12-19

    如何实现 Java 对象的深拷贝?(java对象的深拷贝怎么实现)

    在Java编程中,对象的拷贝是一个常见的操作。深拷贝和浅拷贝是两种不同的拷贝方式,深拷贝会创建一个新的对象,该对象包含原始对象的所有属性值的副本,而浅拷贝只是创建了原始对象的引用的副本。本文将介绍如何在Java中实现对象的深拷贝。一、为什么需要对象的深拷
    如何实现 Java 对象的深拷贝?(java对象的深拷贝怎么实现)
    Java2024-12-16

    在 Java 中怎样实现对象的深拷贝?(Java中如何实现对象的深拷贝)

    在Java编程中,对象的拷贝是一个常见的操作。其中,深拷贝和浅拷贝是两种不同的拷贝方式。浅拷贝只是复制了对象的引用,而深拷贝则会创建一个新的对象,并复制原对象的所有属性。本文将介绍在Java中如何实现对象的深拷贝。一、为什么需要对象的深拷贝?
    在 Java 中怎样实现对象的深拷贝?(Java中如何实现对象的深拷贝)
    Java2024-12-19

    在Java中,如何实现对象的拷贝?

    开发中可以使用第三方库如Apache Commons Lang的SerializationUtils类或Google的Guava库来实现对象的深拷贝。这些库提供了更加灵活和方便的深拷贝实现方式,同时也提供了更多的自定义选项和错误处理机制。
    GuavaJava拷贝2024-11-30

    Java 对象到底是如何创建的?类加载机制是什么?对象的内存布局和访问方式有哪些?

    本章深入解析了类加载机制对对象创建的支持,探讨了 JVM 的内存布局、访问方式及分配策略。通过理解这些底层原理,开发者可以有效优化代码性能,并在内存问题排查中更加游刃有余。
    JVM分配策略2024-11-28

    Python中如何实现一个线程安全的缓存对象

    Python中如何实现一个线程安全的缓存对象随着多线程编程在Python中的越来越被广泛应用,线程安全性变得愈发重要。在并发环境中,多个线程同时读写共享资源时,可能会导致数据不一致或者意外的结果。为了解决这个问题,我们可以使用线程安全的缓存
    2023-10-22

    编程热搜

    • Python 学习之路 - Python
      一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
      Python 学习之路 - Python
    • chatgpt的中文全称是什么
      chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
      chatgpt的中文全称是什么
    • C/C++中extern函数使用详解
    • C/C++可变参数的使用
      可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
      C/C++可变参数的使用
    • css样式文件该放在哪里
    • php中数组下标必须是连续的吗
    • Python 3 教程
      Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
      Python 3 教程
    • Python pip包管理
      一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
      Python pip包管理
    • ubuntu如何重新编译内核
    • 改善Java代码之慎用java动态编译

    目录