Python深复制浅复制or深拷贝浅拷贝。python中颇复制和浅复制。

1. copy.copy 浅拷贝 只拷贝父对象,不见面拷贝对象的内的分段对象。(比死拷贝更加节约内存)
2. copy.deepcopy 深拷贝 拷贝对象及其子对象

转载:http://blog.csdn.net/vicken520/article/details/8227524

所以一个简短的事例说明如下:

java中呢不时接触见这种题材。时间原因即未写java方面啦

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

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完全是同一转头事。

酷易理解: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的震慑

 

#!/usr/bin/env python3

#antuor:Alan

import copy
# 数字, 字符串
print('-----------------------------------数字---------------------------------')
a1 = 123           ###赋值
a2 = 123
print (id(a1))
print ('数字赋值:',id(a2))
print('-----------------------------------字符串---------------------------------')
a3 = 'asd'
a4 =a3
print (id(a3))
print ('字符串赋值:',id(a4))
print('-----------------------------------数字,字符串深浅拷贝---------------------------------')
a5 = 'alan'
a6 =copy.copy(a5)       ###浅拷贝
a7 =copy.deepcopy(a5)   ###深拷贝
print (id(a5))
print ('字符串浅拷贝:',id(a6))
print ('字符串深拷贝:',id(a7))

"""字符串和数字,对这三种方法,用的是同一个内存地址"""



print('-----------------------------------元祖,列表,字典---------------------------------')
print('---------------------字典-------------------------')
n1 = {'k1':'wu','k2':133,'k3':['alan',123]}
n2 =n1
print(id(n1))
print('字典赋值:',id(n2))
n3 = copy.copy(n1)     ###只拷贝第一层
n4 = copy.deepcopy(n1) ###深拷贝
print('字典浅拷贝:',id(n3))
print('字典深拷贝:',id(n4))
print('---------------------第1层-------------------------')
print(id(n1['k1']))
print('深浅拷贝第一层:',id(n3['k1']))
print('深浅拷贝第一层:',id(n4['k1']))

print('---------------------第2层-------------------------')
print(id(n1['k3'][1]))
print('浅拷贝第二层:',id(n3['k3'][1]))
print('深拷贝第二层:',id(n4['k3'][1]))

print('-----------------------------------浅拷贝应用---------------------------------')
dic = {
    "cpu":[80,],
    "mem":[80,],
    "disk":[80,]
}

print("原数据:",dic)
new_copy_dic = copy.copy(dic)
new_copy_dic['cpu'][0] = 50    ###因为新数据是对旧数据的浅拷贝,只拷贝父对象,不拷贝子对象,所以新子对象变影响旧,旧子对象影响新
print("浅拷贝后原数据:",dic)
print("浅拷贝数据:",new_copy_dic)

print('-----------------------------------深拷贝应用---------------------------------')
#################################应用: 深拷贝###########################
dic = {
    "cpu":[80,],
    "mem":[80,],
    "disk":[80,]
}
print("原数据:",dic)
new_deepcopy_dic = copy.deepcopy(dic)
new_deepcopy_dic['cpu'] = 90
print("深拷贝后原数据:",dic)
print("深拷贝数据:",new_deepcopy_dic)

  

===========

浅拷贝是依拷贝的仅仅是本对象元素的援,换句话说,浅拷贝产生的靶子自我是新的,但是她的情节无是新的,只是对原本对象的一个引用。这里产生个例子
>>> 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完全是一模一样扭转事

相关文章