Python对象的比较、拷贝

目录

1.'==' 和'is'的比较

2.浅拷贝和深度拷贝

2.1 浅拷贝

2.2 深拷贝

2.3 小结

---

首先我们来看个例子，思考下这些语句的背后发生了什么。

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

比如：

• l2 是 l1 的浅拷贝（shallow copy）还是深度拷贝（deep copy）呢？
• a == b是比较两个对象的值相等，还是两个对象完全相等呢？

1.'==' 和'is'的比较

我们先来看看'==' 和'is'的比较，等于（==）和 is 是 Python 中对象比较常用的两种方式。简单来说，'=='操作符比较对象之间的值是否相等，比如下面的例子，表示比较变量 a 和 b 所指向的值是否相等。

a == b

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

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

a = 10
b = 10

print(a == b)
print(id(a))
print(id(b))
print(a is b)

结果：

True
4362847856
4362847856
True

这里，首先 Python 会为 10 这个值开辟一块内存，然后变量 a 和 b 同时指向这块内存区域，即 a 和 b 都是指向 10 这个变量，因此 a 和 b 的值相等，id 也相等，a == b和a is b都返回 True。

不过，需要注意，对于整型数字来说，以上a is b为 True 的结论，只适用于 -5 到 256 范围内的数字。比如下面这个例子：

需要注意的问题：在PyCharm中运行时会发现a和b的id是一样的，在Python解释器运行就是不一样的， 你可以试试。

解释：因为在Pycharm中运行这段代码是属于同一个代码块，如果对代码块的概念不太了解可以去网上查一下。Python出于对性能的考虑，但凡是不可变对象，在同一个代码块中的对象，只有是值相同的对象，就不会重复创建，而是直接引用已经存在的对象。

a = 257
b = 257
id(a)
140539753943088
id(b)
140539753943344
a == b
True
a is b
False

这里我们把 257 同时赋值给了 a 和 b，可以看到a == b仍然返回 True，因为 a 和 b 指向的值相等。但奇怪的是，a is b返回了 false，并且我们发现，a 和 b 的 ID 不一样了，这是为什么呢？

事实上，出于对性能优化的考虑，Python 内部会对 -5 到 256 的整型维持一个数组，起到一个缓存的作用。这样，每次你试图创建一个 -5 到 256 范围内的整型数字时，Python 都会从这个数组中返回相对应的引用，而不是重新开辟一块新的内存空间。

但是，如果整型数字超过了这个范围，比如上述例子中的 257，Python 则会为两个 257 开辟两块内存区域，因此 a 和 b 的 ID 不一样，a is b就会返回 False 了。

通常来说，在实际工作中，当我们比较变量时，使用'=='的次数会比'is'多得多，因为我们一般更关心两个变量的值，而不是它们内部的存储地址。但是，当我们比较一个变量与一个单例（singleton）时，通常会使用'is'。一个典型的例子，就是检查一个变量是否为 None：

if a is None:
      ...

if a is not None:
      ...

这里注意，比较操作符'is'的速度效率，通常要优于'=='。因为'is'操作符不能被重载，这样，Python 就不需要去寻找，程序中是否有其他地方重载了比较操作符，并去调用。执行比较操作符'is'，就仅仅是比较两个变量的 ID 而已。

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

参考：python之运算符重载

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

答案自然是否定的。我们来看下面一个例子：

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

# 元组是不可变的，但元组可以嵌套，它里面的元素可以是列表类型，列表是可变的，所以如果我们修改了元组中的某个可变元素，那么元组本身也就改变了, 之前用'is'或者'=='操作符取得的结果，可能就不适用了
t1[-1].append(5)
t1 == t2
False

2.浅拷贝和深度拷贝

你知道Python 中的浅拷贝（shallow copy）和深度拷贝（deep copy）分别指什么吗？

2.1 浅拷贝

先看下浅拷贝的例子:

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

l2
[1, 2, 3]

l1 == l2
True

l1 is l2
False

这里，l2 就是 l1 的浅拷贝。当然，对于可变的序列，我们还可以通过切片操作符':'完成浅拷贝，比如下面这个列表的例子：

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 同时指向这个元组。

浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用。因此，如果原对象中的元素不可变，那倒无所谓；但如果元素可变，浅拷贝通常会带来一些副作用，尤其需要注意。

我们来看下面的例子：

list1 = [[1, 2], (30, 40)]
# 浅拷贝
list2 = list(l1)

# 列表追加和子列表追加
list1.append(100)
list1[0].append(3)

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

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

# 元组合并拼接（元祖无法修改但是可以合并）
list1[1] += (50, 60)
list1
[[1, 2, 3], (30, 40, 50, 60), 100]

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

• 首先初始化了一个列表 list1，里面的元素是一个列表和一个元组
• 然后对 list1 执行浅拷贝，赋予 list2
• 浅拷贝里的元素是对原对象元素的引用
• 接着list1.append(100)，表示对 list1 的列表新增元素 100，这个操作不会对 list2 产生任何影响，因为 l2 和 list1 作为整体是两个不同的对象，并不共享内存地址。操作过后 l2 不变，l1 会发生改变。
• list1[0].append(3)，这里表示对 list1 中的第一个列表新增元素 3。因为 list2 是 list1 的浅拷贝，list2 中的第一个元素和 list1 中的第一个元素，共同指向同一个列表，因此 list2 中的第一个列表也会相对应的新增元素 3。操作后 list1 和 list2 都会改变。
• 最后是list1[1] += (50, 60)，因为元组是不可变的，这里表示对 list1 中的第二个元组拼接，然后重新创建了一个新元组作为 list1 中的第二个元素，而 list2 中没有引用新元组，因此 list2 并不受影响。操作后 list2 不变，list1 发生改变。

通过这个例子，你可以很清楚地看到使用浅拷贝可能带来的副作用。因此，如果我们想避免这种副作用，完整地拷贝一个对象，你就得使用深度拷贝。

2.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 都不变。因为此时的 l1 和 l2 完全独立，没有任何联系。不过，深度拷贝也不是完美的，往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环：

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

x
[1, [...]]

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

上面这个例子，列表 x 中有指向自身的引用，因此 x 是一个无限嵌套的列表。但是我们发现深度拷贝 x 到 y 后，程序并没有出现 stack overflow 的现象。这是为什么呢？其实，这是因为深度拷贝函数 deepcopy 中会维护一个字典，记录已经拷贝的对象与其 ID。拷贝过程中，如果字典里已经存储了将要拷贝的对象，则会从字典直接返回，我们来看相对应的源码就能明白：

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 # 如果字典里已经存储了将要拷贝的对象，则直接返回
        ...    

2.3 小结

（1）赋值
在 Python 中，对象的赋值就是简单的对象引用，这点和 C++不同

（2）浅拷贝(shallow copy)
浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象（划重点）的引用。浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的 copy 函数。

（3）深拷贝(deep copy)
深拷贝只有一种形式，copy 模块中的 deepcopy()函数。深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空间开销要高。

（4）拷贝的注意点

• 对于非容器类型，如数字、字符，以及其他的“原子”类型，没有拷贝一说，产生的都是原对象的引用。
• 如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝。