python什么是深拷贝

python

Python 浅拷贝

常见的浅拷贝的方法,是使用数据类型本身的构造器,比如下面两个例子:

list1 = [1, 2, 3]

list2 = list(list1)

print(list2)

print("list1==list2 ?",list1==list2)

print("list1 is list2 ?",list1 is list2)

set1= set([1, 2, 3])

set2 = set(set1)

print(set2)

print("set1==set2 ?",set1==set2)

print("set1 is set2 ?",set1 is set2)

运行结果为:

[1, 2, 3]

list1==list2 ? True

list1 is list2 ? False

{1, 2, 3}

set1==set2 ? True

set1 is set2 ? False

在上面程序中,list2 就是 list1 的浅拷贝,同理 set2 是 set1 的浅拷贝。

当然,对于可变的序列,还可以通过切片操作符“:”来完成浅拷贝,例如:

list1 = [1, 2, 3]

list2 = list1[:]

print(list2)

print("list1 == list2 ?",list1 == list2)

print("list1 is list2 ?",list1 is list2)

运行结果为:

[1, 2, 3]

list1 == list2 ? True

list1 is list2 ? False

除此之外,Python 还提供了对应的函数 copy.copy() 函数,适用于任何数据类型。其用法如下:

import copy

list1 = [1, 2, 3]

list2 = copy.copy(list1)

print(list2)

print("list1 == list2 ?",list1 == list2)

print("list1 is list2 ?",list1 is list2)

运行结果为:

[1, 2, 3]

list1 == list2 ? True

list1 is list2 ? False

不过需要注意的是,对于元组,使用 tuple() 或者切片操作符 ':' 不会创建一份浅拷贝,相反它会返回一个指向相同元组的引用:

tuple1 = (1, 2, 3)

tuple2 = tuple(tuple1)

print(tuple2)

print("tuple1 == tuple2 ?",tuple1 == tuple2)

print("tuple1 is tuple2 ?",tuple1 is tuple2)

运行结果为:

(1, 2, 3)

tuple1 == tuple2 ? True

tuple1 is tuple2 ? True

此程序中,元组 (1, 2, 3) 只被创建一次,t1 和 t2 同时指向这个元组。

看到这里,也许你可能对浅拷贝有了初步的认识。浅拷贝,指的是重新分配一块内存,创建一个新的对象,但里面的元素是原对象中各个子对象的引用。

对数据采用浅拷贝的方式时,如果原对象中的元素不可变,那倒无所谓;但如果元素可变,浅拷贝通常会出现一些问题,例如:

list1 = [[1, 2], (30, 40)]

list2 = list(list1)

list1.append(100)

print("list1:",list1)

print("list2:",list2)

list1[0].append(3)

print("list1:",list1)

print("list2:",list2)

list1[1] += (50, 60)

print("list1:",list1)

print("list2:",list2)

运行结果为:

list1: [[1, 2], (30, 40), 100]

list2: [[1, 2], (30, 40)]

list1: [[1, 2, 3], (30, 40), 100]

list2: [[1, 2, 3], (30, 40)]

list1: [[1, 2, 3], (30, 40, 50, 60), 100]

list2: [[1, 2, 3], (30, 40)]

此程序中,首先初始化了 list1 列表,包含一个列表和一个元组;然后对 list1 执行浅拷贝,赋予 list2。因为浅拷贝里的元素是对原对象元素的引用,因此 list2 中的元素和 list1 指向同一个列表和元组对象。

接着往下看,list1.append(100) 表示对 list1 的列表新增元素 100。这个操作不会对 list2 产生任何影响,因为 list2 和 list1 作为整体是两个不同的对象,并不共享内存地址。操作过后 list2 不变,list1 会发生改变。

再来看,list1[0].append(3) 表示对 list1 中的第一个列表新增元素 3。因为 list2 是 list1 的浅拷贝,list2 中的第一个元素和 list1 中的第一个元素,共同指向同一个列表,因此 list2 中的第一个列表也会相对应的新增元素 3。

最后是 list1[1] += (50, 60),因为元组是不可变的,这里表示对 list1 中的第二个元组拼接,然后重新创建了一个新元组作为 list1 中的第二个元素,而 list2 中没有引用新元组,因此 list2 并不受影响。

Python 深拷贝

通过这个例子,你可以很清楚地看到使用浅拷贝可能带来的副作用。如果想避免这种副作用,完整地拷贝一个对象,就需要使用深拷贝。所谓深拷贝,是指重新分配一块内存,创建一个新的对象,并且将原对象中的元素,以递归的方式,通过创建新的子对象拷贝到新对象中。因此,新对象和原对象没有任何关联。

Python 中以 copy.deepcopy() 来实现对象的深度拷贝。比如上述例子写成下面的形式,就是深度拷贝:

import copy

list1 = [[1, 2], (30, 40)]

list2 = copy.deepcopy(list1)

list1.append(100)

print("list1:",list1)

print("list2:",list2)

list1[0].append(3)

print("list1:",list1)

print("list2:",list2)

list1[1] += (50, 60)

print("list1:",list1)

print("list2:",list2)

运行结果为:

list1: [[1, 2], (30, 40), 100]

list2: [[1, 2], (30, 40)]

list1: [[1, 2, 3], (30, 40), 100]

list2: [[1, 2], (30, 40)]

list1: [[1, 2, 3], (30, 40, 50, 60), 100]

list2: [[1, 2], (30, 40)]

可以看到,无论 list1 如何变化,list2 都不变。因为此时的 list1 和 list2 完全独立,没有任何联系。

不过,深度拷贝也不是完美的,往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用,那么程序很容易陷入无限循环,例如:

import copy

list1 = [1]

list1.append(list1)

print(list1)

list2 = copy.deepcopy(list1)

print(list2)

运行结果为:

[1, [...]]

[1, [...]]

此例子中,列表 x 中有指向自身的引用,因此 x 是一个无限嵌套的列表。但是当深度拷贝 x 到 y 后,程序并没有出现栈溢出的现象。这是为什么呢?

其实,这是因为深度拷贝函数 deepcopy 中会维护一个字典,记录已经拷贝的对象与其 ID。拷贝过程中,如果字典里已经存储了将要拷贝的对象,则会从字典直接返回。通过查看 deepcopy 函数实现的源码就会明白:

def deepcopy(x, memo=None, _nil=[]):

    """Deep copy operation on arbitrary Python objects.

       

    See the module's __doc__ string for more info.

    """

   

    if memo is None:

        memo = {}

    d = id(x) # 查询被拷贝对象 x 的 id

    y = memo.get(d, _nil) # 查询字典里是否已经存储了该对象

    if y is not _nil:

        return y # 如果字典里已经存储了将要拷贝的对象,则直接返回

        ...

网,大量的免费python教程,欢迎在线学习!

以上是 python什么是深拷贝 的全部内容, 来源链接: utcz.com/z/521747.html

回到顶部