深入理解 Python 的对象拷贝和内存布局

最新推荐文章于 2024-04-23 20:09:57 发布
最新推荐文章于 2024-04-23 20:09:57 发布
阅读量323 收藏 1
点赞数 2
文章标签： python pycharm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73136678/article/details/128571590
版权

前言

在本篇文章当中主要给大家介绍 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 = }")
复制代码

在本篇文章当中我们将对上面的程序进行详细的分析。

Python 对象的内存布局

首先我们介绍一下一个比较好用的关于数据在内存上的逻辑分布的网站，pythontutor.com/visualize.h…

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

从上面的输出结果来看 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
复制代码

copy模块

在 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]
复制代码

撕开 Python 对象的神秘面纱

我们现在简要看一下 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 内部实现列表的结构体，帮助大家深入理解列表对象的内存布局。

以上就是本篇文章的所有内容了，我是恶霸，我们下期再见！！！

python_copy
wanchaopeng的博客
11-09 341
浅copy data = { "name":"chaoyang", "age":"28", "scores":{ "语文":130, "数学":60, "英语":98, } } d = data data["age"] = 20 print(d) {'name': 'chaoyang', 'age': 20, 'scores': {'语文': 130, '数学': 60, '英语': 98}} 为何是20呢，因为d=
python 类 对象 内存_python对象和类的内存布局是什么？
weixin_42361764的博客
02-19 433
基本上，pythons类和实例都是对象。当您测试MyClass()的大小时，您是在查询实例对象的内存大小，当您为MyClass执行此操作时，您正在测试类对象的大小。在两个对象都有自己的字段，这就是大小不同的原因，类对象需要比实例更多的内存也就不足为奇了。在python中类的实例是一种字典，它将名称与python对象(函数、字段等)相关联。实际上，它们存储在MyClass().__dict__字典中...
python中的深浅copy
qq_44611586的博客
07-21 516
深浅copy 复制，首先我们从切片技术说起。它应用于所有的序列，包括：列表，字符串，元祖。但是切片不能应用于字典，对于字典只能使用D.copy() 和 D.deepcopy()方法。 下面具体说一下深浅copy，可以应用于序列，也可以应用于字典 import copy a ={'a':1,'b':2} x = copy.copy(a) #浅拷贝：只拷贝顶级的对象，或者说父级对象 y = copy.deepcopy(a) #深拷贝：拷贝所有的对象，顶级对象及其嵌套对象。 #或者
个人总结 - python内存管理机制原理
老鹰的博客
08-19 858
内存管理 Python中的内存管理机制的层次结构提供了4层，其中最底层则是C运行的malloc和free接口，往上的三层才是由Python实现并且维护的。 Layer0层是C运行的malloc和free接口 Layer1层则是在Layer0层的基础之上对其提供的接口进行了统一的封装 这是因...
Python——对象操作的内存分析
My Blogs
11-23 2928
文章目录对象的本质变量的本质序列的内存分析字符串字符串缓存池字符串的比较一个例子列表字典：底层原理和内存分析一个键值对创建的过程检索一个键值对的过程集合函数的内存分析 对象的本质 Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值） 组成。 1）标识：用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数id(obj) 可返回对象obj...
【Python数据结构内存剖析】：深入探索内存布局与优化技巧
在这一章节中，我们将深入浅出地了解Python的基本数据结构，包括其定义、特点及应用场景。通过这一章节的介绍，读者将对Python数据结构有一个全面的初步认识，并为进一步深入学习打下坚实的基础。 Python中的数据...
Python append函数内存管理机制：深入理解内存分配和释放
[Python append函数内存管理机制：深入理解内存分配和释放](https://pic3.zhimg.com/80/v2-d1eba24c39b87f1795cc074b4f5c6c3e_1440w.webp) # 1. Python 内存管理基础** Python 采用引用计数和垃圾回收相结合的内存...
【Python对象引用机制】：数据结构内存引用的深入解析
[【Python对象引用机制】：数据结构内存引用的深入解析](http://wsfdl.oss-cn-qingdao.aliyuncs.com/pythonobjectmutable.png) # 1. Python对象引用机制概述 Python作为一门高级编程语言，其内存管理机制对于程序员...
python内存管理变量_Python内存管理机制 之 变量与对象
weixin_42511396的博客
03-02 113
参考链接：https://www.cnblogs.com/geaozhang/p/7111961.html#lajihuishou目录一、变量与对象1、变量，通过变量指针引用对象2、对象，类型已知，每个对象都包含一个头部信息(头部信息：类型标识符和引用计数器)3、引用所指判断一、变量与对象1、变量，通过变量指针引用对象变量指针指向具体对象的内存空间，取对象的值。2、对象，类型已知，每个对象都包含一...
Python的内存管理（浅拷贝与深拷贝）
zzqingyun的博客
12-17 1270
????欢迎来到智能优化算法的世界 ????博客主页：卿云阁 ????欢迎关注????点赞????收藏⭐️留言???? ????本文由卿云阁原创！ ????本阶段属于筑基阶段之一，希望各位仙友顺利完成突破 ????首发时间：????2021年12月11日???? ✉️希望可以和大家一起完成进阶之路！ ????作者水平很有限，如果发现错误，请留言轰炸哦！万分感谢！ 目录 0️⃣整数和短小的字符 1️⃣判断对象和对象的关系 2️⃣字符串驻留机制 3️⃣可变对象与不可变对象
python的内存划分
佐杰的博客
03-13 3379
1、python python 在定义变量时，变量名和变量值都是需要存储的，分别对应内存的两块区域：堆区和栈区 1、变量名与变量值内存地址 的关联关系存在于栈区 2、变量值存在堆区，内存管理回收的则是堆区的内容 定义变量 x=10 ,y=20 2、直接引用和间接引用 直接引用是指从栈区出发直接引用到的内存地址 间接引用是从栈区出发引用到堆后，再进一步引用才能到达的内存地址 3、循环引用 ...
搞懂python的内存视图memoryview
最新发布
酌沧
04-23 1090
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
python中的copy.deepcopy()
flyingluohaipeng的博客
11-20 6999
copy.copy()是浅拷贝，只拷贝父对象，不会拷贝对象的内部的子对象。copy.deepcopy()是深拷贝，会拷贝对象及其子对象，哪怕以后对其有改动，也不会影响其第一次的拷贝。
深入挖掘Python列表：揭秘内存管理与性能优化的6大技巧
![深入挖掘Python列表：揭秘内存管理与性能优化的6大技巧](https://substackcdn.com/image/fetch/w_1200,h_600,c_fill,f_jpg,q_auto:good,fl_progressive:steep,g_auto/...# 1. Python列表基础与内存模型 ...
python对象的深浅拷贝
tallercc的博客
10-28 763
python对象的赋值实际上是简单的对象引用。也就是说当你创建一个对象然后把它赋值给另一个变量的时候，python并没有拷贝这个对象，而是这个对象的引用。参考下面的例子： 新建列表li，并把li赋值给li2，此时li与li2的id是相同的。但是当你改变li2时，li也会随之改变。为什么会这样呢？这就是浅拷贝。对一个对象进行浅拷贝其实是创建了一个类型根原来一样，其内容是原来对象元素的使用，换句话说，
python基础 -15- 深浅拷贝
迷雾总会解
08-06 844
浅拷贝 data = { "name": "alex", "age": 18, "scores": { "语文": 130, "数学": 60, "英语": 98, } } # 浅拷贝 data_copy = data.copy() # 再看一下各自的内存地址,可以发现指向的内存地址不一样 print("data的内存地址：", id(data), "\tdata_copy的内存地址：", id(data_copy)) pr
python浅拷贝copy.copy()与深拷贝copy.deepcopy()
gdd1990shl的博客
02-02 249
import copy#导入copy模块 class MobilePhone:#定义MobilePhone类。解释器执行 class 语句,创建一个类名为MobilePhone的对象。 def __init__(self,cpu,screen):#定义构造函数__init__（）方法，用来初始化实例对象的实例属性 self.cpu=cpu#实例(instance)属性，属于实例对象 self.screen=screen class CPU:#定义CPU类 de
对PyObject的认识
wangyuquanliuli的专栏
01-05 4565
最近一直在看《python源码剖析》，现在将自己的认识一步步记录下来，既方便大家分享讨论，共同进步，也方便我自己以后的回顾复习 对象是Python中非常重要的一个概念，需要明确的是在Python中任何事物都是对象（包括类型对象，yes,10是一个对象，10的类型int也是一个对象）.我们知道，python是用c来实现的，那么具体这个对象在源代码里面是怎么表示的呢？ PyObject非常
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值