Python对象的比较、拷贝
'==' VS 'is'
等于（==）和 is 是python中对象比较常用的两种方式。简单来说，'=='操作符比较对象之间的值是否相等，比如下面的例子，表示比较变量 a 和 b 所指向的值是否相等。
a == b
在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都会从这个数组中返回相应的引用，而不是重新开辟一块新的内存空间。
通常来说，在实际工作中，当我们比较变量时，使用'=='的次数会比'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__函数回去遍历列表中的元素，比较它们的顺序和值是否相等。
不过，对于不可变（immutable）的变量，如果我们之前用'=='或者'is'比较过，结果是不是就一直不变了呢？答案自然是否定的。我们来看下面一个例子：
t1 = (1, 2, [3, 4]) t2 = (1, 2, [3, 4]) t1 == t2 True t1[-1].append(5) t1 == t2 False
我们知道元组是不可变的，但元组可以嵌套，它里面的元素可以是列表类型，列表是可变的，所以如果我们修改了元组中的某个可变元素，那么元组本身也就改变了，之前用'is' 或者'=='操作符取得的结果，可能就不适用了。
这一点，你在日常写程序时一定要注意，在必要的地方请不要省略条件检查。
浅拷贝和深度拷贝
常见的浅拷贝的方法，是使用数据类型本身的构造器。
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
当然，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 同时指向这个元组。
浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是源对象中子对象的引用。因此，如果原对象中的元素不可变，那倒无所谓；如果元素可变，浅拷贝通常会带来一些副作用，尤其需要注意。
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]
通过这个例子，你可以很清楚地看到使用浅拷贝可能带来的副作用。因此，如果我们想避免这种副作用，完整地拷贝一个对象，你就得使用深度拷贝。
所谓深拷贝，是指重新分配一块内存，创建一个新的对象，并且将源对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中，因为，新对象和源对象没有任何关联。
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 # 如果字典里已经存储了将要拷贝的对象，则直接返回 ...
补充：
import copy x = 1 y = copy.deepcopy(x) x is y # failed True x = '1' y = copy.deepcopy(x) x is y # failed True x = (1) y = copy.deepcopy(x) x is y # failed True x = (1,[]) y = copy.deepcopy(x) x is y # succeed False
当对数值，字符串，仅包含数值/字符串的元组进行深/浅拷贝会失效。也就是文中所提到的，会返回一个指向相同数值，字符串，元组的引用。
