你好，我是景霄。
在前面的学习中，我们其实已经接触到了很多 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中对象比较常用的两种方式。简单来说，'=='操作符比较对象之间的值是否相等，比如下面的例子，表示比较变量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都会从这个数组中返回相对应的引用，而不是重新开辟一块新的内存空间。
但是，如果整型数字超过了这个范围，比如上述例子中的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__函数会去遍历列表中的元素，比较它们的顺序和值是否相等。
不过，对于不可变（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）。
对于这两个熟悉的操作，我并不想一上来先抛概念让你死记硬背来区分，我们不妨先从它们的操作方法说起，通过代码来理解两者的不同。
先来看浅拷贝。常见的浅拷贝的方法，是使用数据类型本身的构造器，比如下面两个例子：
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 # 如果字典里已经存储了将要拷贝的对象，则直接返回
...
总结
今天这节课，我们一起学习了Python中对象的比较和拷贝，主要有下面几个重点内容。
- 比较操作符
'=='表示比较对象间的值是否相等，而'is'表示比较对象的标识是否相等，即它们是否指向同一个内存地址。 - 比较操作符
'is'效率优于'=='，因为'is'操作符无法被重载，执行'is'操作只是简单的获取对象的ID，并进行比较；而'=='操作符则会递归地遍历对象的所有值，并逐一比较。 - 浅拷贝中的元素，是原对象中子对象的引用，因此，如果原对象中的元素是可变的，改变其也会影响拷贝后的对象，存在一定的副作用。
- 深度拷贝则会递归地拷贝原对象中的每一个子对象，因此拷贝后的对象和原对象互不相关。另外，深度拷贝中会维护一个字典，记录已经拷贝的对象及其ID，来提高效率并防止无限递归的发生。
思考题
最后，我为你留下一道思考题。这节课我曾用深度拷贝，拷贝过一个无限嵌套的列表。那么。当我们用等于操作符'=='进行比较时，输出会是什么呢？是True或者False还是其他？为什么呢？建议你先自己动脑想一想，然后再实际跑一下代码，来检验你的猜想。
import copy
x = [1]
x.append(x)
y = copy.deepcopy(x)
# 以下命令的输出是？
x == y
欢迎在留言区写下你的答案和学习感想，也欢迎你把这篇文章分享给你的同事、朋友。我们一起交流，一起进步。
精选留言
2019-06-17 14:51:20
SCAR说的很对，程序会报错：'RecursionError: maximum recursion depth exceeded in comparison'。因为x是一个无限嵌套的列表，y深度拷贝x也是一个无限嵌套的列表，理论上x==y应该返回True，但是x==y内部执行是会递归遍历列表x和y中每一个元素的值，由于x和y是无限嵌套的，因此会stack overflow，报错
2019-06-12 09:11:42
之前课中做阶乘的例子，如果大于一定的整数，也是会出现递归错误，究其原因也是python的递归层数是有限定的。
def factorial(n):
return 1 if n <=1 else n*factorial(n-1)
factorial(5000)
RecursionError: maximum recursion depth exceeded in comparison
在sys模块中有个方法可以得到递归的层数:
import sys
sys.getrecursionlimit()
3000
当然你也可以重新设定递归的层数：
sys.setrecursionlimit(10000)
那是不是可以设定无穷大呢？理论上可以，但你的程序崩溃也是一定的，我的mac内存是16G，如果把递归层数设定到1百万，大概跑到35000层左右，我的服务就挂了。
2019-07-08 21:45:11
一、赋值:
在 Python 中，对象的赋值就是简单的对象引用，这点和 C++不同
二、浅拷贝(shallow copy):
浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象的引用。浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的 copy 函数。
三、深拷贝(deep copy):
深拷贝只有一种形式，copy 模块中的 deepcopy()函数。深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空间开销要高。
四、拷贝的注意点:
1、对于非容器类型，如数字、字符，以及其他的“原子”类型，没有拷贝一说，产生的都是原对象的引用。
2、如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝。
2019-06-12 22:19:35
深拷贝，都不可变
2019-06-12 19:43:39
2019-06-12 10:56:59
b = 257
print(id(a))
print(id(b))
在pycharm中运行结果中一致
2019-06-12 09:56:38
x == y
1. 出现如下错误信息，推测原因是x与y的列表进行一项一项比较，因无限嵌套，导致递归深度失败。
RecursionError: maximum recursion depth exceeded in comparison
2. 两个问题，需要老师解答
既然是无限嵌套，为什么x.append(x)没有报错？
运行len(x),结果为2,更是不可理解
2019-06-20 12:01:53
1. ‘==’ 用于比较值的大小，‘is’用于比较对象的内存地址是否相同，指向同一个内存地址
2. 对与整数型，范围在（-5 ~ 256 ）之间的整形数，‘==’ 与 ‘is’ 结果相同，原因在于python建立了一个数组缓存，创建对象时直接引用缓存
3. 浅拷贝：定义：重新分配一片内存，生成新的对象，里面的元素是原对象中子对象的引用。
生成方法： 可以通过数据构造器（list、set）完成浅拷贝，对于可变序列可以使用切片完成浅拷贝，对于元组而言，tupletuple()和切片不创建浅拷贝，指向相同元组的引用，还可以使用import copy, 使用copy.copy()来进行浅拷贝。
浅拷贝是对元素的引用，所以对于子对象，如果子对象是不可变，没有影响，如果是可变的序列，会带来一些影响
4. 深拷贝，重新分配一块内存，创建一个新的对象，将原对象中的元素以递归的方式全部拷贝。深拷贝中会维持一个字典，记录已经拷贝的对象以及对象的ID，防止出现无限递归。
2019-06-12 09:30:17
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
当对数值、字符串、仅包含数值/字符串的元组进行浅/深拷贝会失效。 也就是文中所提到的, 会返回一个指向相同数值、字符串、元组的引用~
2019-06-12 11:07:30
2019-06-18 12:12:25
1. 为什么 len(x) 是 2。
>> x = [1]
>> id(x)
4378931848
>> x.append(x)
>> id(x)
4378931848
>> id(x[0])
4304870656
>> id(x[1])
4378931848
>> x[1] is x
True
>> len(x)
2
2. 为什么 x == y 会报错。
‘==’ 搜到 x[1] 时发现 x[1] 指向一个列表 x'，又去遍历这个列表 x' 的每个值，然后发现这个列表里的 x'[1] 又指向一个列表 x'', ... 实际上 x, x', x'' 都是同一个，无限循环。
2019-06-12 15:18:49
b = 258
在python解释器中使用id查看确实内存地址不同，但是使用vs code同样也是python解释器，内存地址是相同的。
思考题中 x 是循环嵌套的列表，比较时超过了递归限制报错
2019-06-28 14:59:44
2019-06-12 20:17:54
print(id(x[1][1]))
print(id(x[1][1][1][1][1][1][1][1]))
x 和 y 各自形成了一个闭环
2019-06-12 11:58:37
2019-06-12 06:49:49
1）a = 257
b = 257
print(id(a))
print(id(b))
---------
4526886832
4526886832 这个和环境有关么？我用VsCode编辑运行和jupter运行的结果不一致。juterNotebook返回的不一样的
2019-06-12 02:02:57
一开始猜想是 print True，因为当 x append 自身的时候，程序是没有报错的，返回的结果是：[1, [...]]，我想程序既然没有报错，则 [...] 表示的应该是对应的一个最大限度的值，只是这里它没有将其表示出来；当我们 deepcopy 的时候 y 获得了同样的结果，表示深度拷贝成功；用 == 来比较两个 list 其实是比较里面的值是否相等，所以应该返回 True。
当然尝试的结果是报错 “RecursionError: maximum recursion depth exceeded in comparison”，我想应该是内部的比较函数递归比较的时候递归深度过长，也就是列表的递归嵌套超过了其限度
2019-06-20 12:46:38
a,b = 257,257 这种写法，引用的同一个地址，a is b 返回True，猜想是由于内部优化了，
深拷贝中，对不可变的元素，会直接引用
import copy
l1 = [[1,2],(3,4),[257,258]]
l2 = copy.deepcopy(l1)
print([id(i) for i in l1], [id(i) for i in l2], , sep='\n')
print([id(i) for j in l1 for i in j], [id(i) for j in l2 for i in j], sep='\n') # 这里地址都相同
2019-06-19 15:29:28
2019-06-12 13:08:34
2，执行了代码以后，如评论一样RecursionError: maximum recursion depth exceeded in comparison，递归层次过深
3，然后把代码 x.append(x) 注释掉，程序就正常返回True。也就是说问题在这行代码上。
4，网上search了一下，x.append(x)会产生一个无限嵌套列表（评论也有这么说），y深拷贝了x，也就是y拷贝了每一个x的自对象。
5，而==操作符会递归遍历对象所有值，所以出现了递归过深的错误。
不知道我的分析对不对？请老师指点