15 | Python对象的比较、拷贝_python对象相等是深拷贝还是浅拷贝-优快云博客

1.回顾

在前面的课中，已经学许多python对象比较和复制的例子

if a == b:
    ...

这里的l2就是l1拷贝得到的。

l1 = [1, 2, 3]
l2 = list(l1)

l2是l1的浅拷贝(shallow copy)还是深拷贝(deep copy)呢？

a == b是比较两个对象的值相等，还是两个对象完全相等呢？

1.“==”VS“is”

== 和is是python中对象比较常用的两种方式，“==”操作符比较对象之间的值是否相等，eg

a == b

而is 操作符比较是对象的身份标识是否相等，即它们是否是同一个对象，是否指向同一个内存地址。

在python中，每个对象的身份标识，都是通过函数id(object)获得。因此，'is'操作符，相当于比较对象之间的ID是否相等，下面的例子：

a = 10
b = 10

a == b
True

id(a)
4427562448

id(b)
4427562448

a is b
True

python会给10开辟一个内存，然后变量a和b同时指向这地位内存区域，即a和b都是指向10这个变量，因此，a和b的值相等，id也相等，a==b,和a is b都返回True.

不过要注意的是，对于整型数字来说，以上 a is b为True的结论，只适于-5到255范围内的数字。

a = 257
b = 257

a == b
True

id(a)
4473417552

id(b)
4473417584

a is b
False

if a is None:
      ...

if a is not None:
      ...

比较操作符'is'通常优于“==”.因为is操作符不能重载，这样，python就不需要去寻找，程序中是否有其他重载了比较操作符，并去调用，执行比较操作符'is'就仅是比较两个变量的ID而已。

但是“==”操作符不同，执行a ==b 相当于去执行a.__eq__(b)，而python大部分的数据类型会去重载__eq__这个函数，其内部的处理会复杂一些。对于列表,__eq__函数会去遍历列表中的元素，比较它们的顺序和值是否相等。

对于不可变的变量，如果我们之前用'=='或'is‘比较过，结果是不是就上直不变了呢？

t1 = (1, 2, [3, 4])
t2 = (1, 2, [3, 4])
t1 == t2
True

t1[-1].append(5)
t1 == t2
False

答案是否定的，我们知道元组是不可变的，但元组可以嵌套，它里面的元素可以是列表类型，列表是可变的，所以如果我们修改了元组中的某个可变元素，那么元组本身也就改变了，之前用'is'或是'=='操作符取得结果，可能就不适用。

2.浅拷贝和深度拷贝

常见的浅拷贝方法，是使用数据类型本身的构造器，比如：

l1 = [1, 2, 3]
l2 = list(l1)

l2
[1, 2, 3]

l1 == l2
True

l1 is l2
False

s1 = set([1, 2, 3])
s2 = set(s1)

s2
{1, 2, 3}

s1 == s2
True

s1 is s2
False

这里l2就是l1的浅拷贝，s2是s1的浅拷贝，对于可变的序列，我们还可以通过切片操作符":"完成浅拷贝，如下

l1 = [1, 2, 3]
l2 = l1[:]

l1 == l2
True

l1 is l2
False

当然，python中也提供了相对应的函数copy.copy()，适用于任何数据类型：

import copy
l1 = [1, 2, 3]
l2 = copy.copy(l1)

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

t1 = (1, 2, 3)
t2 = tuple(t1)

t1 == t2
True

t1 is t2
True

这里，元组(1,2,3)只被创建一次，t1和t2同时指向这个元组。浅拷贝就是重新分配一块内存，创建上个新对对象里面的元素是原对象中子对象的引用，因此，如果原对象中的元互素不变，那无所谓，但变了，浅拷贝会的副作用，所以要注意。

l1 = [[1, 2], (30, 40)]
l2 = list(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2
[[1, 2, 3], (30, 40)]

l1[1] += (50, 60)
l1
[[1, 2, 3], (30, 40, 50, 60), 100]

l2
[[1, 2, 3], (30, 40)]

首先初始化一个列表l1,里面的元素是一个列表和一个元组，然后对l1执行浅拷贝，赋予l2.因为浅拷贝里的元素是对原元素的引用，因此l2中的元素和l1指向同一个列表和元组对象。

2.深拷贝

python中copy.deepcopy（）来实现对象的深度拷贝

import copy
l1 = [[1, 2], (30, 40)]
l2 = copy.deepcopy(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2 
[[1, 2], (30, 40)]

无论l1如何变，l2不会变。是独立的。

不过深拷贝也不完美，如果拷贝对象中存在指向自身的引用，那么会陷入无限循环。

import copy
x = [1]
x.append(x)

x
[1, [...]]

y = copy.deepcopy(x)
y
[1, [...]]

3.总结

4.思考

跑一下代码，检验自己的想法

import copy
x = [1]
x.append(x)

y = copy.deepcopy(x)

# 以下命令的输出是？
x == y

浅拷贝，不可变的不可变，可变的依旧可变
深拷贝，都不可变