[py]python的深拷贝和浅拷贝

Python深复制浅复制or深拷贝浅拷贝
简单点说

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

用一个简单的例子说明如下：

>>>import copy
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)

很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。

第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同：

>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976

至于如何看深/浅拷贝的区别，可以通过下面的操作来展现：

>>> a.append(5)    #操作1
>>> a[4].append('hello')   #操作2

这时再查看结果：

>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]

可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ [‘a‘, ‘b‘, ‘c‘, ‘hello‘]）改变时会影响到c；d是深拷贝，完全不受a的影响

简单点说

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

用一个简单的例子说明如下：

>>>import copy
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)

很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。

第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同：

>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976

至于如何看深/浅拷贝的区别，可以通过下面的操作来展现：

>>> a.append(5)    #操作1
>>> a[4].append('hello')   #操作2

这时再查看结果：

>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]

可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ [‘a‘, ‘b‘, ‘c‘, ‘hello‘]）改变时会影响到c；d是深拷贝，完全不受a的影响

简单点说

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

用一个简单的例子说明如下：

>>>import copy
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)

很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。

第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同：

id(a)
19276104
id(b)
19276104
id(c)
19113304
id(d)
19286976

至于如何看深/浅拷贝的区别，可以通过下面的操作来展现：
a.append(5) #操作1
a[4].append(‘hello‘) #操作2

这时再查看结果：
a
[1, 2, 0, 4, [‘a‘, ‘b‘, ‘c‘, ‘hello‘], 5]
b
[1, 2, 0, 4, [‘a‘, ‘b‘, ‘c‘, ‘hello‘], 5]
c
[1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘, ‘hello‘]]
d
[1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]]

可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ ['a', 'b', 'c', 'hello']）改变时会影响到c；d是深拷贝，完全不受a的影响

?

===========

浅拷贝是指拷贝的只是原对象元素的引用，换句话说，浅拷贝产生的对象本身是新的，但是它的内容不是新的，只是对原对象的一个引用。这里有个例子
aList=[[1, 2], 3, 4]
bList = aList[:] #利用切片完成一次浅拷贝
id(aList)
3084416588L
id(bList)
3084418156L
aList[0][0] = 5
aList
[[5, 2], 3, 4]
bList
[[5, 2], 3, 4]

可以看到，浅拷贝生产了一个新的对象bList,但是aList的内容确实对aList的引用，所以但改变aList中值的时候，bList的值也跟着变化了。

但是有点需要特别提醒的，如果对象本身是不可变的，那么浅拷贝时也会产生两个值，见这个例子：
aList = [1, 2]
bList = aList[:]
bList
[1, 2]
aList
[1, 2]
aList[1]=111
aList
[1, 111]
bList
[1, 2]

为什么bList的第二个元素没有变成111呢？因为数字在python中是不可变类型！！

这个顺便回顾下Python标准类型的分类：
可变类型： 列表，字典
不可变类型：数字，字符串，元组

理解了浅拷贝，深拷贝是什么自然就很清楚了。
python中有一个模块copy，deepcopy函数用于深拷贝，copy函数用于浅拷贝。

最后，对象的赋值是深拷贝还是浅拷贝？
对象赋值实际上是简单的对象引用
a = 1
id(a)
135720760
b = a
id(b)
135720760
```
a和b完全是一回事。

参考: python的深浅拷贝

原文地址：https://www.cnblogs.com/iiiiiher/p/8616210.html

时间： 2024-11-08 23:01:26

[py]python的深拷贝和浅拷贝的相关文章

python 中 深拷贝和浅拷贝的理解

在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一个变量之后,实际上只是拷贝了这个对象的引用. 我们先用  利用切片操作和工厂方法list方法 来阐述一下浅拷贝. 举个栗子: Tom = ['Tom', ['age', 10]] Jack = Tom[:] ……切片操作 June = list(Tom) 接下来查看一下 上述三个变量的引用: >>

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

Python中深拷贝与浅拷贝的区别: 原创 2017年04月20日 16:58:35 标签: python / python两种拷贝 / 深拷贝浅拷贝 / 拷贝区别 1661 定义: 在Python中对象的赋值其实就是对象的引用.当创建一个对象,把它赋值给另一个变量的时候,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已. 浅拷贝:拷贝了最外围的对象本身,内部的元素都只是拷贝了一个引用而已.也就是,把对象复制一遍,但是该对象中引用的其他对象我不复制 深拷贝:外围和内部元素都进行了拷贝

python：深拷贝，浅拷贝，内存管理

深拷贝和浅拷贝都是对象的拷贝,本质的区别是拷贝出来的对象的地址是否和原对象一样,也就是地址的复制还是值的复制的区别. 可变对象:直接在对象所指的地址上把值改了,这个对象依然指向这个地址. 不可变对象:一个对象所指向的地址上的值是不能修改的,如果修改了这个对象的值,它所指向的地址就改变了. 深拷贝就是完全跟以前就没有任何关系了,原来的对象怎么改都不会影响当前对象 浅拷贝,原对象的list元素改变的话会改变当前对象,如果当前对象中list元素改变了,也同样会影响原对象. 内存管理机制 python的

python的深拷贝和浅拷贝

---恢复内容开始--- 数字和字符串                                                                                                                                                                                                                               数字和字符串中的

python的深拷贝与浅拷贝

对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制?份内容. 两个变量的内容其实为一个地址,如果要在复制的同时分配新的地址则需要用到深拷贝和浅拷贝的命令 lst1 = ["何炅", "杜海涛","周渝?", ["麻花藤", "?芸", "周笔畅"]]lst2 = lst1.copy() 此时是吧lst1的第一层列表复制给了lst2 但是嵌套的列表

【转】python的深拷贝和浅拷贝

来源:https://www.cnblogs.com/lixiaoliuer/p/6094698.html 数字和字符串 数字和字符串中的内存都指向同一个地址,所以深拷贝和浅拷贝对于他们而言都是无意义的 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 import copy a = 123                #赋值 print(id(a))           #输出存储变量的地址 b = a print(id(b)) b = copy.copy(

关于Python中深拷贝与浅拷贝的理解（一）---概念

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

浅析Python中深拷贝和浅拷贝

按照以下不同情况,在IDE中逐个解除注释,就明白了 import copy """ 第一种情况,不可变类型变量,都是引用 """ # a = 1 # a = (11, 222, 333) # a = 'string' # a = True # b = a # # print(id(a)) # print(id(b)) # # c =copy.copy(a) # d = copy.deepcopy(a) # print(id(c)) # print

python list的深拷贝与浅拷贝-以及初始化空白list的方法(2)

接上一篇 其实python对于深拷贝与浅拷贝的处理方式依然是很灵活的,甚至有一个专门的工具包copy来做个事情 来看以下这组list的拷贝方法: 已知lista是一个已经定义好了的list listb=lista 注意,这个并不是一个copy的过程,这里lista与listb完全等同 以下提供一些copy方法,但注意是深copy还是浅copy: 定义:lista=[2,[4,5]] listb=lista[:] listb=list(lista) listb=[i for i in lista]