Python 深浅拷贝

共享引用和增强赋值
1
2
3
4
5
6
7
8
#共享引用及在原处修改：对于可变对象，要注意尽量不要共享引用！
    #共享引用和相等测试：
        L = [1], M = [1], L is M            # 返回False
        L = M = [1, 2, 3], L is M           # 返回True，共享引用
#增强赋值和共享引用：普通+号会生成新的对象，而增强赋值+=会在原处修改
        L = M = [1, 2]
        L = L + [3, 4]                      # L = [1, 2, 3, 4], M = [1, 2]
        L += [3, 4]                         # L = [1, 2, 3, 4], M = [1, 2, 3, 4]

赋值简单的拷贝对象，两个id相同

转载自：会发光的二极管

原文链接：谈谈python中的深拷贝和浅拷贝

最近面试被问到python中深拷贝和浅拷贝的知识
这里进行下总结，以便今后复习
python中的深拷贝和浅拷贝和java里面的概念是一样的，所谓浅拷贝就是对引用的拷贝，所谓深拷贝就是对对象的资源的拷贝。
首先，对赋值操作我们要有以下认识：

  1. 赋值是将一个对象的地址赋值给一个变量，让变量指向该地址（ 旧瓶装旧酒 ）。(共享引用)
  2. 修改不可变对象（str、tuple）需要开辟新的空间（不可变对象不能修改，只能替换）
  3. 修改可变对象（list等）不需要开辟新的空间
  • 浅拷贝仅仅复制了容器中元素的地址

b = a[:],copy.copy(a)

1
2
3
4
5
6
7
8
9
10
11
12
>>> a=['hello',[1,2,3]]
>>> b=a[:] #b = copy.copy(a)
>>> [id(x) for x in a]
[55792504, 6444104]
>>> [id(x) for x in b]
[55792504, 6444104]
>>> a[0]='world'
>>> a[1].append(4)
>>> print(a)
['world', [1, 2, 3, 4]]
>>> print(b)
['hello', [1, 2, 3, 4]]

这里可以看出，未修改前，a和b中元素的地址都是相同的，不可变的hello
和可变的list地址都一样，说明浅拷贝知识将容器内的元素的地址复制了一份。这可以通过修改后，b中字符串没改变，但是list元素随着a相应改变得到验证。

浅拷贝是在另一块地址中创建一个新的变量或容器，但是容器内的元素的地址均是源对象的元素的地址的拷贝。也就是说新的容器中指向了旧的元素（ 新瓶装旧酒 ）。

  • 深拷贝，完全拷贝了一个副本，容器内部元素地址都不一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from copy import deepcopy
>>> a=['hello',[1,2,3]]
>>> b=deepcopy(a)
>>> [id(x) for x in a]
[55792504, 55645000]
>>> [id(x) for x in b]
[55792504, 58338824]
>>> a[0]='world'
>>> a[1].append(4)
>>> 
>>> print(a)
['world', [1, 2, 3, 4]]
>>> print(b)
['hello', [1, 2, 3]]

这里可以看出，深拷贝后，a和b的地址以及a和b中的元素地址均不同，这是完全拷贝的一个副本，修改a后，发现b没有发生任何改变，因为b是一个完全的副本，元素地址与a均不同，a修改不影响b。

深拷贝是在另一块地址中创建一个新的变量或容器，同时容器内的元素的地址也是新开辟的，仅仅是值相同而已，是完全的副本。也就是说（ 新瓶装新酒 ）。

转载自：会发光的二极管

原文链接：谈谈python中的深拷贝和浅拷贝

自定义拷贝机制

使用 _copy_ 和 __deepcopy__ 可以完成对一个对象拷贝的定制。这里不展开了，有机会再探讨自定义拷贝。

总结

  • Python中对象的赋值都是进行对象引用（内存地址）传递
  • 使用copy.copy()，a = lis[:]可以进行对象的浅拷贝，它复制了对象，但对于对象中的元素，依然使用原始的引用.,内存地址相同
  • 如果需要复制一个容器对象 （list，dict等），以及它里面的所有元素（包含元素的子元素），可以使用copy.deepcopy()进行深拷贝，创建了新的对象。
  • 对于非容器类型（如str,数字、字符串、和其他’原子’类型的对象）没有被拷贝一说
  • 如果元祖变量只包含原子类型对象，则不能深拷贝，看下面的例子

####

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import copy

#目的是更改数据后，原来的数据不变，而拷贝后的数据会随时更新！
dic = {
"cpu":[80,],
"mem":[80,],
"disk":[80,]
}
print("before:",dic)

#new_dic = copy.copy(dic)     ##浅拷贝后的数据更新会把原来和新的字典内容的数据都更新！
shallow_cpy = copy.copy(dic) #浅拷贝
shallow_cpy['cpu'] = 532
print('newshallow',shallow_cpy)
new_dic = copy.deepcopy(dic)   ##深拷贝只更新拷贝后的数据，而原来的数据保留不变！
new_dic["cpu"][0] = 50
print(dic)
print(new_dic)

1
2
3
4
5
6
a = [1,2]
a[1] = a
print(a[1])
#打印结果
 
[1, [...]]

图解深浅拷贝

区别