python 深拷贝和浅拷贝浅析

简单点说

1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象。id会变化
2. copy.deepcopy 深拷贝 拷贝对象及其子对象。id会变化

>>> import copy
>>> a=[1,2,3,[4,5,6]]
>>> b=a                              #普通赋值
>>> c=copy.copy(a)            #浅拷贝
>>> d=copy.deepcopy(a)    #深拷贝
>>> print(a,b,c,d)
[1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5,
6]]
#------------------------------------------------------------------------------
>>> a[3].append("chen")
>>> print(a)
[1, 2, 3, [4, 5, 6, ‘chen‘]]
>>> print(b)
[1, 2, 3, [4, 5, 6, ‘chen‘]]
>>> print(c)
[1, 2, 3, [4, 5, 6, ‘chen‘]]
>>> print(d)
[1, 2, 3, [4, 5, 6]]
#------------------------------------------------------------------------------
>>> a.append("wang")
>>> print(a)
[1, 2, 3, [4, 5, 6, ‘chen‘], ‘wang‘]
>>> print(b)
[1, 2, 3, [4, 5, 6, ‘chen‘], ‘wang‘]
>>> print(c)
[1, 2, 3, [4, 5, 6, ‘chen‘]]
>>> print(d)
[1, 2, 3, [4, 5, 6]]                            

dd

时间: 2024-10-06 23:23:21

python 深拷贝和浅拷贝浅析的相关文章

完全理解python深拷贝和浅拷贝

import copya = [1, 2, 3, 4, ['a', 'b']]  #原始对象b = a  #赋值,传对象的引用c = copy.copy(a)  #对象拷贝,浅拷贝d = copy.deepcopy(a)  #对象拷贝,深拷贝a.append(5)  #修改对象aa[4].append('c')  #修改对象a中的['a', 'b']数组对象print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d 输出结果:a = 

python深拷贝和浅拷贝之简单分析

title: python 深拷贝和浅拷贝 tags: python,copy,deepcopy grammar_cjkRuby: true --- python 深拷贝和浅拷贝 python的变量的赋值都是引用 把一个变量赋值给一个变量,不是拷贝这个对象,而是拷贝这个变量的引用 直接赋值 传递的是这个变量的引用 浅拷贝 拷贝的是这个变量的引用,会产生新的对象 浅拷贝会产生一个新的对象,但是浅拷贝的内容还是原有对象的引用 看下面的例子 浅拷贝 import copy a = [1, 2, 3,

python 深拷贝和浅拷贝之可变和不可变对象总结

了解深拷贝和浅拷贝之前先要理解可变与不可变对象 python只允许使用引用传递,有可变对象和不可变对象,可变对象:list,dict.不可变对象有:int,string,float,tuple Python int,string,float,tuple不可变举栗子: def int_object(): i = 89 j = 89 print(id(89)) print('i id:' + str(id(i))) print('j id:' + str(id(j))) print(i is j)

python 深拷贝与浅拷贝

浅拷贝的方式有: lst=[1,2,3] (1)直接赋值: lst_cp = lst (2)for循环遍历生成:lst_cp= [i for i in lst] (3)copy模块下,copy.copy仍为浅拷贝 深拷贝的方式 (1)借助copy模块 >>> import copy >>> lst_cp = copy.deepcopy(lst) 以上方法的测试: 注意:因为string类型是不可变类型,所以修改string元素时会新创建一个地址空间放置数据 (1)直接赋

Python深拷贝和浅拷贝

1. Python引用计数[ http://blog.chinaunix.net/uid-26602509-id-3506965.html ] 1.1 引用计数机制 引用计数是计算机编程语言中的一种内存管理技术,是指将资源(可以是对象.内存或磁盘空间等等)的被引用次数保存起来,当被引用次数变为零时就将其释放的过程.使用引用计数技术可以实现自动资源管理的目的.同时引用计数还可以指使用引用计数技术回收未使用资源的垃圾回收算法. 当创建一个对象的实例并在堆上申请内存时,对象的引用计数就为1,在其他对象

Python 深拷贝和浅拷贝的区别

python的复制,深拷贝和浅拷贝的区别    在python中,对象赋值实际上是对象的引用.当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法,        alist=[1,2,3,["a","b"]] (1)直接赋值,传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变 >>> b=alist        >>> print b        

python深拷贝与浅拷贝

浅拷贝:b=copy.copy(a),对引用的拷贝,只拷贝父对象,所以id(b)不等于id(a),但对象内部资源依然引用,内部id(b[0])等于id(a[0]),id(b[4])等于id(a[4]) 深拷贝:c=copy.deepcopy(a),对对象资源的拷贝,id(c)不等于id(a),内部id(c[0])等于id(a[0]),id(c[4])不等于id(a[4]) 注意:因为数字是不可变量,所以数字的id不变,无论深拷贝还是浅拷贝,id(b[0]).id(c[0])都等于id(a[0])

python深拷贝和浅拷贝的区别

首先深拷贝和浅拷贝都是对象的拷贝,都会生成一个看起来相同的对象,他们本质的区别是拷贝出来的对象的地址是否和原对象一样,也就是地址的复制还是值的复制的区别. 深拷贝和浅拷贝需要注意的地方是可变元素的拷贝,在浅拷贝时:拷贝出来的新对象的地址和原对象是不一样的,但是新对象里面的可变元素(如列表)的地址和原对象里的可变元素的地址是相同的,也就是说浅拷贝它拷贝的是浅层次的数据结构(不可变元素),对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去,而是和原对象里的可变元素指向同一个地址,所以在新

Python 深拷贝和浅拷贝

Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差异的,如果使用的时候不注意,就可能产生意外的结果. 下面本文就通过简单的例子介绍一下这些概念之间的差别. 对象赋值 直接看一段代码: will=["Will",28,["Python","C#","JavaScript"]] wilber=will print id(will) print will print [id(x) for x in will] print id