Python核心技术与实战学习笔记（九）：Python对象的比较和拷贝

1. == 与 is

1.1 应用

==：比较对象之间的值是否相等
is：比较对象身份标识是否相等，即是否为同一个对象

a = 10
b = 10

a == b
True

id(a)
4427562448

id(b)
4427562448

a is b
True

python会为10开辟一个内存空间，然后让a,b指向该内存空间；要注意的是，对于整型数字来说，只有当数字为-5到256之间时才会这样。原因在于：python内部维持着一个-5到256的数组，起到缓存的作用。当要创建一个-5到256的整型数字时，python都会从这个数组返回相对应的引用，而不是为该数开辟内存空间。
当我们创建的不是-5到256之间的数字时，如：

a = 257
b = 257

a == b
True

id(a)
4473417552

id(b)
4473417584

a is b
False

python为257开辟了两个新的内存空间。

1.2 ==与is的效率比较

比较操作符“is”的速度效率通常要优于“==”。这是因为：

• is操作符不能被重载，这样python就不用去程序其他地方查找是否重载了此比较符，并去调用。而执行is比较操作符，就仅仅是比较两个变量的ID而已。
• 对于“==”操作符，执行a==b就相当于去执行a.__eq__(b)，而python大部分数据类型都会去重载__eq__这个函数，其内部处理通常更复杂。比如，对于列表，__eq__函数会去遍历列表中的元素，比较它们的顺序和值是否相等。

immutable变量之间的==判断是否永远不变

创建元组之后，由于它immutable，故不可修改。那么，是不是对于两个值相同的元组，==判断永远成立呢？

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

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

由于元组是可嵌套的，故元组内部还可以嵌套可变类型，可以对其进行修改，这样元组也变了，==不再成立。

因此，在日常程序中，不要因为是immutable就放松警惕，在必要的地方不要省略条件检查。

1.3 浅拷贝与深拷贝

浅拷贝

浅拷贝：拷贝的是原来对象的引用，并开辟新的内存空间存储这些引用。

浅拷贝主要有三种方式：工厂函数，切片操作，copy.copy()方法：

1. 工厂函数：

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

2. 切片操作（可变序列）：

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

l1 == l2
True

l1 is l2
False

3. copy.copy()方法：

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

要注意的是，对于元组，以上三种方式都不会创建浅拷贝，而只是返回指向相同元组的引用：

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

t1 == t2
True

t1 is t2
True

显然，由于浅拷贝里的元素只是对原先对象的引用（实际上都指向了同一块内存区域），故原先对象的改变也会导致浅拷贝元素的改变。

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], (30, 40)]
[[1, 2, 3], (30, 40)] # l2的第一个元素是引用，和l1的第一个元素一样指向了同一个列表

l1[1] += (50, 60) # 元组是不可变的，这里表示的是对元组的拼接
l1
[[1, 2, 3], (30, 40, 50, 60), 100]

l2
[[1, 2, 3], (30, 40)]  # 元组不能浅拷贝，l2中没有引用新元组，因此l2不受影响。

因此，若要避免浅拷贝带来的副作用，则要使用深拷贝。

深拷贝的方式

深拷贝是指重新分配一块内存，创建一个新的对象，并且将原对象的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象与原对象没有任何关联。

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)]

深拷贝会维护一个字典，记录已经拷贝的对象及其ID，来提高效率并防止无限递归的发生。