Python核心丨对象的比较、拷贝

Python对象的比较、拷贝

---

‘==’ VS ‘is’

等于 (==) 和 is 是 Python 中对象比较常用的两种方式。简单来说，’=='操作符比较对象之间值是否相等。

示例

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 is b 为True的结论，只适用于 -5 到 256 范围内的数字。

a = 257
b = 257

a == b
True

id(a)
4473417552

id(b)
4473417584

a is b
False

出于对性能优化的考虑，Python内部会对 -5 到 256 的整型维持一个数组，起到一个缓存的作用。

每次创建一个 -5 到256 范围内的整型数字时，Python都会从这个数组中返回相对应的应用，而不是重新开辟一块新的内存空间。

如果超过这个范围，Python则会为两个 257 开辟两块内存区域。因此 a 和 b 的 ID 不一样。

通常来说，比较变量时，使用’==‘的次数比较多。而当比较一个变量与一个单例（singleton）时，通常会使用’is’。

示例

if a is None:
      ...

if a is not None:
      ...

比较操作符 ‘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

浅拷贝和深度拷贝

浅拷贝（shallow copy）

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

相应的函数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 指向同一个列表和元组对象。

l1.append(100)，表示对 l1 的列表新增元素100.这个操作不会对 l2 产生任何影响，因为 l2 和 l1 作为整体是两个不同的对象，并不共享内存地址。

而l1[0].append(3)，这里表示对 l1 中的第一个列表新增元素3。因为 l2 是 l1 的浅拷贝，l2 中的第一个元素和 l1 中的第一个元素，共同指向同一个列表，因此 l2 中的第一个列表也会相对应的新增元素 3。

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

深拷贝（deep copy）

是指重新分配一块内存，创建一个新的对象，并且将原来对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。

因此，新对象和原对象没有任何关联。

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 都不变。