'=='和'is'是python中对象比较常用的两种方式。简单来说，'=='操作符比较对象之间的值是否相等，比如下面的例子，表示比较变量a和b所指向的值是否相等。
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==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'多得多，因为我们一般关心两个变量的值，而不是它们内部的存储地址。但是，当我们比较一个变量与一个单例时，通常会使用'is'。一个典型的例子，就是检查一个变量是否为None：
if a is None:
...
if a is not None:
...
比较操作符'is'的速度效率，通常要优于'=='.因为'is'操作符不能被重载，这样，python就不需要去寻找，程序中是否有其他地方重载了比较操作符，并去调用。执行比较操作符'is'，就仅仅是比较两个变量的ID而已。
但是'=='操作符却不同，执行a==b相当于是去执行a.eq(b)，而python大部分的数据类型都会去重载__eq__这个函数，其内部的处理通常会复杂一些。比如，对于列表，__eq__函数会去遍历列表中的元素，比较它们的顺序和值是否相等。
浅拷贝和深拷贝
常见的浅拷贝的方法，是使用数据类型本身的构造器。
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会发生改变。
l1.append(3)，这里表示对l1中的第一个列表新增元素3。因为l2是l1的浅拷贝，l2中的第一个元素和l1中的第一个元素，共同指向同一个列表，因此l2中的第一个列表也会相对应的新增元素3。操作后l1和l2都会改变
最后是l1[1] += (50, 60)，因为元组是不可变的，这里表示对 l1 中的第二个元组拼接，然后重新创建了一个新元组作为 l1 中的第二个元素，而 l2 中没有引用新元组，因此 l2 并不受影响。操作后 l2 不变，l1 发生改变。
可以看到浅拷贝可能带来的问题，因此如果想要避免这种情况，完整地拷贝 一个对象，就得使用深度拷贝。
深度拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中，因此，新对象和原对象没有任何关联。
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完全独立，没有任何联系。
