python直接赋值、浅拷贝与深拷贝的区别解析

直接赋值:其实就是对象的引用(别名)。

浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。

深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。

实例解析
a = {1: [1,2,3]}
1. b = a: 赋值引用,a 和 b 都指向同一个对象,如下图:
 
2. b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象,但他们的子对象还是指向统一对象(是引用),如下图:
 
3. b = copy.deepcopy(a): 需要导入copy模块,深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的,如下图:

举例:

>>>a = {1: [1,2,3]}
>>> b = a.copy()
>>> a, b
({1: [1, 2, 3]}, {1: [1, 2, 3]})
>>> a[1].append(4)
>>> a, b
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
>>>import copy
>>> c = copy.deepcopy(a)
>>> a, c
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
>>> a[1].append(5)
>>> a, c
({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})
import copy
a = [1, 2, 3, 4, [‘a‘, ‘b‘]] #原始对象

b = a                       #赋值,传对象的引用
c = copy.copy(a)            #对象拷贝,浅拷贝
d = copy.deepcopy(a)        #对象拷贝,深拷贝

a.append(5)                 #修改对象a
a[4].append(‘c‘)            #修改对象a中的[‘a‘, ‘b‘]数组对象

print( ‘a = ‘, a )
print( ‘b = ‘, b )
print( ‘c = ‘, c )
print( ‘d = ‘, d )

###输出###
a =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
b =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
c =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]]
d =  [1, 2, 3, 4, [‘a‘, ‘b‘]]
总结:
1、赋值:简单地拷贝对象的引用,两个对象的id相同。
2、浅拷贝:创建一个新的组合对象,这个新对象与原对象共享内存中的子对象。
3、深拷贝:创建一个新的组合对象,同时递归地拷贝所有子对象,新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象,但不影响它们的相互独立性。

浅拷贝和深拷贝的不同仅仅是对组合对象来说,所谓的组合对象就是包含了其它对象的对象,如列表,类实例。而对于数字、字符串以及其它“原子”类型,没有拷贝一说,产生的都是原对象的引用。

原文地址:https://www.cnblogs.com/jeasonit/p/12052828.html

时间: 2024-11-07 22:44:41

python直接赋值、浅拷贝与深拷贝的区别解析的相关文章

Python中的赋值,浅拷贝和深拷贝的区别

赋值 内存地址的引用,所有的改变都会同步 测试代码 #coding:utf-8 import copy a=['a','b',1,[1,2,3]] b = a #对象赋值,所有改动都会联动 a.append('d') a[0]='aaa' a[3].append(4) print a print b 运行结果 ['aaa', 'b', 1, [1, 2, 3, 4], 'd'] ['aaa', 'b', 1, [1, 2, 3, 4], 'd'] 浅拷贝 str,num等深浅拷贝都一样,list

python中赋值,浅拷贝,深拷贝的区别

1.首先,对被操作对象分类,对于不可变对象而言,如字符串.数字.tuple等,这三种操作是等价的,都是引用 import copy a='apple'b=ac=copy.copy(a)d=copy.deepcopy(a)print(id(a))print(id(b))print(id(c))print(id(d) 输出: 1840734496184073449618407344961840734496 可见,这四个变量都指向同一块内存地址,即'apple'这个字符串所在的地址 2.对可变对象(或

Python中浅拷贝和深拷贝的区别

Python中浅拷贝和深拷贝的区别 浅拷贝和深拷贝示意图 如上图,简单点说 1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 数字,字符串是不可变类型 列表,字典是可变类型 我们看下面的案例 案例一:浅拷贝 >>> import copy     #导入copy模块                >>> s=['name',['savings',100.0]] #赋值给s >

js中对象的浅拷贝和深拷贝的区别

js中对象的浅拷贝和深拷贝的区别 浅度拷贝:复制一层对象的属性,并不包括对象里面的为引用类型的数据,当改变拷贝的对象里面的引用类型时,源对象也会改变. 深度拷贝:重新开辟一个内存空间,需要递归拷贝对象里的引用,直到子属性都为基本类型.两个对象对应两个不同的地址,修改一个对象的属性,不会改变另一个对象的属性. 数据的类型: 一般数据(值传递):字符,数值,布尔,undefined 拷贝(复制)时,传递的是值,修改新数据,不会影响老数据 复杂数据(引用传递):对象 拷贝(复制)时,传递的是内存地址的

关于python中赋值、浅拷贝、深拷贝之间区别的深入分析

大家都知道,在python中复制一个对象有多种方法,其中常用的是赋值.浅拷贝和深拷贝,这三者之间有哪些区别和哪些坑呢? 首先,定义一下: 赋值:  a =1    b =a    a赋值给了b 浅拷贝: a = []  b = a.copy() 或者import copy             b = copy.copy(a) 深拷贝:import copy  a = []   b = copy.deepcopy(a) 未完待续

python列表--浅拷贝与深拷贝的区别

首先得说说列表为什么需要拷贝,就是为了解决简单赋值操作,传地址的问题,因为赋值过去的列表,其实指向的是同一个地址,问题说明看代码 a = [1,2,3] b = a # list类型,简单赋值操作,是传地址 print(id(a)) print(id(b)) b[1] = 6 print(b) print(a) 执行结果,输出的是: 2460317409864 2460317409864 [1, 6, 3] [1, 6, 3] #同一地址,修改b的列表,a也会同时改变. 为了解决以上问题,lis

赋值、浅拷贝以及深拷贝的区别

字符串赋值 >>> >>> str1 = 'standby' >>> >>> str2 = str1 >>> >>> print str1==str2, str1 is str2 True True >>> >>> id(str1) 139792206350496 >>> id(str2) 139792206350496 >>>

赋值、浅拷贝、深拷贝的区别

直接赋值:其实就是对象的引用(别名). 浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象. 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象. 1.b = a: 赋值引用,a 和 b 都指向同一个对象. 2.b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象,但他们的子对象还是指向统一对象(是引用). 3.b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的.

浅拷贝和深拷贝的区别?

先考虑一种情况,对一个已知对象进行拷贝,编译系统会自动调用一种构造函数--拷贝构造函数,如果用户未定义拷贝构造函数,则会调用默认拷贝构造函数. //main.cpp #include <iostream> #include "student.h" int main() { Student s1; Student s2(s1);//Student s2 = s1;//复制对象 return 0; } //student.h #ifndef STUDENT_H #define