Python中的深拷贝和浅拷贝

Question

如题所述

Answer 1

这篇文章主要介绍了Python中的深拷贝和浅拷贝详解,本文讲解了变量-对象-引用、可变对象-不可变对象、拷贝等内容,需要的朋友可以参考下
要说清楚Python中的深浅拷贝，需要搞清楚下面一系列概念:
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝)
【变量-对象-引用】
在Python中一切都是对象，比如说:3, 3.14, Hello, [1,2,3,4],{a:1}......
甚至连type其本身都是对象，type对象
Python中变量与C/C++/Java中不同，它是指对象的引用，Python是动态类型，程序运行时候，会根据对象的类型
来确认变量到底是什么类型。
单独赋值： 比如说：
复制代码 代码如下:
a = 3
在运行a=3后，变量a变成了对象3的一个引用。在内部，变量事实上是到对象内存空间的一个指针
因为Python的变量不过是对象的引用，或指向对象的指针，因此在程序中可以经常改变变量引用
复制代码 代码如下:
x = 42 #变量绑定到整型对象
x = Hello #现在又成了字符串
x = [1,2,3] #现在又成了列表
专业表述如下:
变量是一个系统表的元素，拥有指向对象的连接的空间
对象是被分配的一块内存，存储其所代表的值
引用是自动形成的从变量到对象的指针
特别注意: 类型属于对象，不是变量
比如像刚才的a=3, 整数对象3包含了两重信息
1.值为3
2.一个头部信息：告诉Pthyon，这是个整数对象[相当于一个指向int的指针]
共享引用: 比如说：
复制代码 代码如下:
a = 3
b = a
在运行赋值语句b = a之后，变量a和变量b指向了同一个对象的内存空间.
从上图可以看到，a和b，其id完全一样，指向同一个整数对象3，或者说同一块内存
如果删掉a后, 不会影响b
拷贝概念的引入就是针对:可变对象的共享引用潜在的副作用而提出的.
【可变对象-不可变对象】
在Python中不可变对象指：一旦创建就不可修改的对象，包括字符串，元祖，数字
在Python中可变对象是指：可以修改的对象，包括：列表、字典
上面说的a,b都是整数，整数是不可变对象，如果是可变对象的话，就是另外一回事了。
复制代码 代码如下:
L1 = [2,3,4] #L1变量指向的是一个可变对象:列表
L2 = L1 #将L1值赋给L2后，两者共享引用同一个列表对象[1,2,3,4]
L1[0] = 200 #因为列表可变，改变L1中第一个元素的值
L1; L2 #改变后，L1，L2同时改变，因为对象本身值变了
[200, 3, 4]
[200, 3, 4]
如果不想改变列表L2的值，有两种方法:切片 和 copy模块
复制代码 代码如下:
L1 = [2,3,4]
L2 = L1
id(L1);id(L2) #共享引用一个可变对象
45811784L
45811784L
L2 = L1[:] #切片操作
id(L1);id(L2) #切片后，对象就不一样了
45811784L
45806920L
L1[0] = 200
L1;L2 #L1发生改变，L2没有变化
[200, 3, 4]
[2, 3, 4]
【拷贝】
1. 切片技术应用于所有的序列，包括：列表、字符串、元祖
但切片不能应用于字典。对字典只能使用D.copy()方法或D.deepcopy()方法.
2. 深浅拷贝，即可用于序列，也可用于字典
复制代码 代码如下:
import copy
X = copy.copy(Y) #浅拷贝：只拷贝顶级的对象，或者说：父级对象
X = copy.deepcopy(Y) #深拷贝：拷贝所有对象，顶级对象及其嵌套对象。或者说：父级对象及其子对象
如果字典只有顶级对象:
如果字典中嵌套对象:
【结论】
深浅拷贝都是对源对象的复制，占用不同的内存空间
如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象
如果源对象不止一级目录的话，源做任何改动，都要影响浅拷贝，但不影响深拷贝
序列对象的切片其实是浅拷贝，即只拷贝顶级的对象

Answer 2

1、Python深浅拷贝概念
在Python中，当进行赋值操作时，实际上是将一个对象的应用赋给了一个变量，因此这两个变量指向的是同一个对象。如果我们需要复制一个对象，那么就需要使用拷贝操作。
浅复制是指新建一个对象，然后将原始对象的引用复制给新对象。由于新对象与原始对象同一内存地址，因此一个对象的值被修改后，另一个对象的值也会受到影响。浅拷贝只复制对象的一层内容。
递归复制原始对象及其子对象的所有内容，从而创建一个新的对象，这就是深度复制。由于新对象与原始对象并无共享内存地址，故而二者完全独立，因此更改其中一个对象的值并不会影响另一个对象的值。
2、Python深浅拷贝使用场景
浅拷贝适合于对象层次结构较浅的情况，比如列表、元组、字典等简单对象的复制。如果对象的元素全部为不可变类型，则可以使用浅拷贝来复制该对象。
如果对象层次结构比较复杂，例如嵌套列表的列表或嵌套字典的字典，那么深拷贝就是一个合适的选择。如果一个对象的元素包含可变对象，那么在需要进行拷贝时必须使用深拷贝。
3、Python深浅拷贝注意事项
对于不可变对象，浅拷贝和深拷贝都是相同的。
浅拷贝只会复制可变对象的一层内容，而不会递归复制可变对象包含的子对象。如果需要递归复制子对象，必须使用深拷贝。
当一个对象包含循环引用时，尝试进行深复制可能会导致无限递归，从而导致程序崩溃。因此，在使用深拷贝时，必须小心处理包含循环引用的对象。
在使用深拷贝时，如果对象的层次结构比较复杂，可能会导致性能问题，因此必须小心使用深拷贝。

Answer 3

深拷贝

在Python中，深拷贝意味着创建一个新的对象，并将原始对象的所有内容都复制到新对象中。

在深拷贝中，如果原始对象有子对象，那么也将对子对象进行深拷贝，并将其复制到新的对象中。这意味着，每个子对象都将包含在新的对象中，而不是与原始对象共享。

浅拷贝

在Python中，浅拷贝将创建一个新的对象，并将原始对象中的所有元素复制到新对象中。如果原始对象有子对象，那么在浅拷贝中，子对象将不复制，而是引用到原始对象的子对象。

Python深浅拷贝注意事项

对于不可变对象(如数字、字符串、元组等)，浅拷贝和深拷贝都是相同的。

浅拷贝只会复制可变对象(例如列表和字典)的一层内容，而不会递归复制可变对象包含的子对象。如果需要递归复制子对象，必须使用深拷贝。

当一个对象包含循环引用时，尝试进行深复制可能会导致无限递归，从而导致程序崩溃。因此，在使用深拷贝时，必须小心处理包含循环引用的对象。

在使用深拷贝时，如果对象的层次结构比较复杂，可能会导致性能问题，因此必须小心使用深拷贝。

Answer 4

1、浅拷贝
当我们使用Python的赋值操作创建一个新的对象时，它实际上是使用浅拷贝来完成的。这意味着原始对象和新对象共享同一块内存空间，当我们对新对象执行修改或更新操作时会影响原始对象。
让我们以一个简单的例子来说明这一点。假设我们有一个名为list的列表，其中包含三个整数。我们将list1赋值给list2，然后将list2的第一个元素更改为1。请看下面的代码：
'''python
list1=[1,2,3]
list2=list1
list2[0]=1
print(list1)#[1,2,3]
print(list2)#[1,2,3]
'''
在这个例子中，我们使用了Python的赋值操作将list1赋值给list2。然后，我们修改了list2的第一个元素。最后，我们打印出list1和list2的值。由于list1和list2实际上是同一个列表，因此它们的值都被更改为[1,2,3]。
2、深拷贝
与浅拷贝相反，深拷贝会创建一个完全新的对象，这个新对象与原始对象具有相同的值，但是它们在内存中具有不同的位置。这意味着当我们对新对象进行修改或更新操作时，原始对象不会受到影响。
让我们看看一个例子。假设我们有一个名为list1的列表，其中包含三个整数。我们将list1深度复制到list2，然后将list2的第一个元素更改为1。请看下面的代码：
'''python
import copy
list1=[1,2,3]
list2=copy.deepcopy(list1)
list2[0]=1
print(list1)#[1,2,3]
print(list2)#[1,2,3]
'''
在这个例子中，我们使用Python的copy模块中的deepcopy函数创建了一个名为list2的完全新的列表。然后，我们修改了list2的第一个元素。最后，我们打印出list1和list2的值。由于list1和list2实际上是不同的对象，因此它们的值仍然分别为[1,
2, 3]和[1, 2, 3]。