在前面的学习中，其实已经接触到了很多Python对象比较和复制的例子，比如判断a和b是否相等的if语句：
if a == b:
...再比如第二个例子，这里l2就是l1的拷贝
l1 = [1, 2, 3]
l2 = list(l1)但可能并不清楚这些语句的背后发生了什么，比如：
- l2是l1的浅拷贝(shallow copy)还是深度拷贝(deep copy)呢？
-
a == b是比较两个对象的值相等，还是两个对象完全相等呢？
关于这些的种种知识，希望接下来有个全面的了解
一、== VS is
等于==和is是Python中对象比较常用的两种方式
1.1 ==操作符
简单来说，==操作符比较对象之间的值是否相等，比如下面的例子，表示比较变量a和b所指向的值是否相等
a == b1.2 is操作符
而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到256范围内的数字，比如下面这个例子：
a = 257
b = 257
a == b
True
id(a)
4473417552
id(b)
4473417584
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
1.3 is None
通常来说，在实际工作中比较变量时，使用==的次数会比is多得多，因为一般更关心两个变量的值，而不是它们内部的存储地址
但是，当比较一个变量与一个单例(singleton)时通常会使用is，一个典型的例子就是检查一个变量是否为None：
if a is None:
...
if a is not None:
...1.4 执行速度效率对比
这里注意，比较操作符is的速度效率，通常要优于== 因为is操作符不能被重载，这样Python就不需要去寻找程序中是否有其他地方重载了比较操作符并去调用。执行比较操作符is，就仅仅是比较两个变量的ID而已
但是==操作符却不同，执行a == b相当于是去执行a.__eq__(b)，而Python大部分的数据类型都会去重载__eq__这个函数，其内部的处理通常会复杂一些。比如对于列表，__eq__函数会去遍历列表中的元素，比较它们的顺序和值是否相等
不过，对于不可变(immutable)的变量，如果之前用==或者is比较过，结果是不是就一直不变了呢？
答案自然是否定的，来看下面一个例子：
t1 = (1, 2, [3, 4])
t2 = (1, 2, [3, 4])
t1 == t2
True
t1[-1].append(5)
t1 == t2
False元组是不可变的，但元组可以嵌套，它里面的元素可以是列表类型，而列表是可变的，所以如果修改了元组中的某个可变元素，那么元组本身也就改变了，之前用is或者==操作符取得的结果可能就不适用了
这一点在日常写程序时一定要注意，在必要的地方请不要省略条件检查
二、浅拷贝和深度拷贝
接下来，一起来看看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
s1 = set([1, 2, 3])
s2 = set(s1)
s2
{1, 2, 3}
s1 == s2
True
s1 is s2
False这里，l2是l1的浅拷贝，s2是s1的浅拷贝
2.1.1 可变序列切片操作符:
当然，对于可变的序列，还可以通过切片操作符:完成浅拷贝，比如下面这个列表的例子：
l1 = [1, 2, 3]
l2 = l1[:]
l1 == l2
True
l1 is l2
False2.1.2 copy.copy()
当然，Python中提供了相对应的函数copy.copy()，适用于任何数据类型：
import copy
l1 = [1, 2, 3]
l2 = copy.copy(l1)2.1.3 元组浅拷贝
不过，需要注意的是对于元组，使用tuple()或者切片操作符:不会创建一份浅拷贝，相反，它会返回一个指向相同元组的引用：
t1 = (1, 2, 3)
t2 = tuple(t1)
t1 == t2
True
t1 is t2
True这里，元组(1, 2, 3)只被创建一次，t1和t2同时指向这个元组
综上，浅拷贝是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用
2.2 可变和不可变元素的浅拷贝
因此，如果原对象中的元素不可变，那倒无所谓，但如果元素可变，浅拷贝通常会带来一些副作用，尤其需要注意。看下面的例子：
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作为整体是两个不同的对象，并不共享内存地址
操作过后l2不变，l1会发生改变：
[[1, 2, 3], (30, 40), 100]- 再看，l1[0].append(3)，这里表示对l1中的第一个列表新增元素3
因为l2是l1的浅拷贝，l2中的第一个元素和l1中的第一个元素，共同指向同一个列表，因此l2中的第一个列表也会相对应的新增元素3
操作后l1和l2都会改变：
l1: [[1, 2, 3], (30, 40), 100]
l2: [[1, 2, 3], (30, 40)]- 最后，l1[1] += (50, 60)，因为元组是不可变的，这里表示对l1中的第二个元组拼接，然后重新创建了一个新元组作为l1中的第二个元素，而l2中没有引用新元组，因此l2并不受影响
操作后l2不变，l1发生改变：
l1: [[1, 2, 3], (30, 40, 50, 60), 100]通过这个例子，可以很清楚地看到使用浅拷贝可能带来的副作用。因此，如果想避免这种副作用，完整地拷贝一个对象就得使用深度拷贝
2.3 深度拷贝
所谓深度拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联
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完全独立，没有任何联系
2.4 深度拷贝无限循环的问题
不过，深度拷贝也不是完美的，往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环：
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 # 如果字典里已经存储了将要拷贝的对象，则直接返回
...
