比较比较操作符 ‘==’ 表示比较对象间的值是否相等，而 ‘is’ 表示比较对象的标识是否相等，即他们是否指向同一个内存地址

比较操作符 ‘is’ 效率优于 ‘==’，因为 ‘is’ 不能被重载，执行 ‘is’ 操作只是简单的获取对象的 id，并进行比较，而 ‘==’ 操作符则会递归的遍历对象的所有值，并逐一比较。

浅拷贝浅拷贝中的元素，是原对象中子对象的引用，因此，如果原对象中的元素是可变的，改变其他也会影响拷贝后的对象，存在一定的副作用。

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,因为 l1 和 l2 作为整体是两个不同的对象，并不共享内存，操作过后 l2 不变，l1 会发生改变。

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

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

深拷贝

深拷贝则会递归地拷贝原对象中的每个子对象，因此拷贝后的对象和原对象互不相关，另外，深拷贝会维护一个字典，记录已经拷贝的对象及其 ID，来提高效率并防止无止境的递归发生。

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

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

...

思考

import copy

x = [1]

x.append(x)

y = copy.deepcopy(x)

# 以下命令的输出是？

x == y

Traceback (most recent call last):

File "", line 1, in

RecursionError: maximum recursion depth exceeded in comparison

因为 x 是一个无限嵌套的列表，y 深度拷贝 x 也是一个无限嵌套的列表，理论上 x == y 应该返回 true，但是 x == y 内部执行是会递归遍历列表内部的，由于无限嵌套，因此报错。