Shallow Copy & Deep Copy in Python list

  今天在写一个小程序的时候用到了2维数组, 顺手就写成了[[0.0]*length]*length, 结果为了这个小错,调试了半个多小时,

其实之前对与浅复制和深复制已经做过学习和总结, 但真正编程用到这些知识时还是掉入了陷阱中. 所以在此做进一步的总结:

  本文通过几个实例来说明Python中list的深复制和浅复制:

>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0][0] = 10         #NO Way
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a[0].append(1)
>>> a
[[1], [1], [1], [1], [1], [1], [1], [1], [1], [1]]
>>> 

  a[0].append(1)后, 如果a的输出结果让你感到有些困惑,你可以参考这里(原因是Python中的*运算采用的是浅复制).

  同样的道理,下面的代码我们应该都能够理解:

>>> a[1].append(9)
>>> a
[[1, 9], [1, 9], [1, 9], [1, 9], [1, 9], [1, 9], [1, 9], [1, 9], [1, 9], [1, 9]]
>>> a[2][1] = 33
>>> a
[[1, 33], [1, 33], [1, 33], [1, 33], [1, 33], [1, 33], [1, 33], [1, 33], [1, 33], [1, 33]]
>>> 

  让我们一起来分析一下:

  对于a(理解为一个2维数组)中的每一个元素都是一个list(理解为一个1维数组), 但我们需要注意的是a的每一个元素a[0],a[1],

a[2]...在内存中占用的是同一段内存区域(浅复制),所以更改(修改值或添加值)任何一个元素(a[0]或a[1]...a[9])都会直接影响到

其它的元素.

  如何验证a中的每一个元素a[0], a[1],...,a[9]在内存中占用相同的区域? 可以通过id方法来验证:

>>> id.__doc__
"id(object) -> integer

Return the identity of an object.  This is guaranteed to be unique amongsimultaneously existing objects.  (Hint: it‘s the object‘s memory address.)"
>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> id(a[0])
3071938316L
>>> id(a[1])
3071938316L
>>> a[0].append(1)
>>> a
[[1], [1], [1], [1], [1], [1], [1], [1], [1], [1]]
>>> id(a[0])
3071938316L
>>> id(a[1])
3071938316L
>>> 

  那么应该怎么实现深复制呢?其实在前面提到的文章中已经介绍了这一方法:  

>>> c = [[] for i in range(10)]
>>> c
[[], [], [], [], [], [], [], [], [], []]
>>> c[0].append(3)
>>> c
[[3], [], [], [], [], [], [], [], [], []]
>>> 

  至此, 我觉得还有一点需要说明:

  一定要理解*操作的对象是谁, 例如: [2]*10得到[2, 2, 2, 2, 2, 2, 2, 2, 2, 2], *10操作的对象是[]中的2, 也就是说*10操

作使list中的元素2复制10次. 同理[[]]*10得到[[], [], [], [], [], [], [], [], [], []],*10操作的对象是[]中的[], 也就是说*10

操作使list中的元素[]浅复制10次, 这10个空list在内存中占有相同的区域(参见上面用id验证部分).

  下面用2段代码作为对比列出来, 便于查看:

>>> a = [2] * 10
>>> a
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
>>> id(a[0])
164067492
>>> id(a[1])
164067492
>>> a[0] = 1  #NOTE
>>> id(a[0])  #NOTE
164067504
>>> id(a[1])
164067492
>>> 
>>> b = [[]] * 10
>>> b
[[], [], [], [], [], [], [], [], [], []]
>>> id(b[0])
3072965964L
>>> id(b[1])
3072965964L
>>> b[0].append(10)
>>> id(b[0])
3072965964L
>>> id(b[1])
3072965964L
>>> b
[[10], [10], [10], [10], [10], [10], [10], [10], [10], [10]]
>>> b[0][0] = 1
>>> b
[[1], [1], [1], [1], [1], [1], [1], [1], [1], [1]]
>>> id(b[0])
3072965964L
>>> id(b[1])
3072965964L
>>> b[0] = [10]
>>> b
[[10], [1], [1], [1], [1], [1], [1], [1], [1], [1]]
>>> id(b[1])
3072965964L
>>> id(b[0])
3072965996L
>>> 
时间: 2024-08-09 07:12:48

Shallow Copy & Deep Copy in Python list的相关文章

Shallow copy and Deep copy

一.来自wikipidia的解释: Shallow copy One method of copying an object is the shallow copy. In that case a new object B is created, and the fields values of A are copied over to B. This is also known as a field-by-field copy,field-for-field copy, or field co

python中的shallow copy 与 deep copy

今天在写代码的时候遇到一个奇葩的问题,问题描述如下: 代码中声明了一个list,将list作为参数传入了function1()中,在function1()中对list进行了del()即删除了一个元素. 而function2()也把list作为参数传入使用,在调用完function1()之后再调用function2()就出现了问题,list中的值已经被改变了,就出现了bug. 直接上代码: list = [0, 1, 2, 3, 4, 5] def function1(list): del lis

copy&amp;mutableCopy 浅拷贝(shallow copy)深拷贝 (deep copy)

本文来自 这里,原文作者微博MicroCai 概念 对象拷贝有两种方式:浅复制和深复制.顾名思义,浅复制,并不拷贝对象本身,仅仅是拷贝指向对象的指针:深复制是直接拷贝整个对象内存到另一块内存中. 一图以蔽之 再简单些说:浅复制就是指针拷贝:深复制就是内容拷贝. 集合的浅复制 (shallow copy) 集合的浅复制有非常多种方法.当你进行浅复制时,会向原始的集合发送retain消息,引用计数加1,同时指针被拷贝到新的集合. 现在让我们看一些浅复制的例子: NSArray *shallowCop

[C++] Deep copy ,Shallow copy, copy constructor,&quot;=&quot;

Deep copy ,Shallow copy, copy constructor,"=" Dog.h #pragma once class Dog { public: char *name; Dog(); Dog(const Dog &it); ~Dog(); void operator =(const Dog &it); }; Dog.cpp #include "Dog.h" #include<string.h> #include&l

Summary: Deep Copy vs. Shallow Copy vs. Lazy Copy

Object copy An object copy is an action in computing where a data object has its attributes copied to another object of the same data type. An object is a composite data type in object-oriented programming languages. The copying of data is one of the

Java里的Deep Copy和Shallow Copy

以前从来没听说过这两个名词,这几天用List和Map的时候发现bug,才第一次在stackoverflow上知道有这么两个简单的专业术语可以形容我遇到的问题. 写下来的都是基于自己的理解,或许不准确,如果以后发现不对再回来修正. 首先,Java的数据类型只有两种:primitive type和object type. 基本数据类型(primitive type)在赋值的时候,只存在一种情况,因为他们的内存位置就是他们的实际值的位置,如果把一个变量赋值给另一个变量,也会在内存增加一个新的值. 对于

有关Ehcache的内容的引用和Java的deep copy

项目使用Ehcache来作为程序和数据库之间的缓冲, 使用过程中会对cache对象做修改, 如plan.setLangSymbol(),发现后面使用cache的地方,取到的数据都是修改后的,所以猜测是cache的浅引用造成的. 实际上,stackoverflow也有人提到此问题<Cache.get() returns deep copy of element?> 至于如何做deep copy,stackoverflow也提到<Copying cached Map<String ,

Deep Copy cv::StereoBM 深度拷贝

在使用OpenCV的三维立体重建的库时,一个重要的步骤就是生成左右视图的差异图Disparity,而控制生成disparity的参数的类是cv::StereoBM,我们有时候需要拷贝一份cv::StereoBM,然后改变其中的参数值,但是如果用默认的等号‘=’来进行拷贝,其实是浅拷贝,如果改变拷贝项的参数值,原来的参数值也会跟着改变,所以我们需要自己写一个深拷贝的函数,如下所示: /** * Deep copy cv::StereoBM bm1 to bm2 */ void copy_bm(co

angular.extend深拷贝(deep copy)

在用到angular.extend的时候,正好碰到一个对象,是层层嵌套的Array, 结果发现只能extend第一层,查阅官文档,确实不支持deep copy: Note: Keep in mind that angular.extend does not support recursive merge (deep copy). 在stackoverflow找到一个方案,只是好像没什么用,看了一下他的写法,原来是在自行判断是否应该进入下一层递归,因为深拷贝的原始需求就是拷贝到最底层的每一个字段,