应该会出错，因为x是一个无限嵌套的列表，y深拷贝于x，按道理来讲 x == y应该是True的，但进行比较操作符“==”的时候，'=='操作符则会递归地遍历对象的所有值，并逐一比较。而python为了防止栈崩溃，递归的层数是要限定的，不会无休下去，所以到了限定的层数，python解释器会跳出错误。执行了一下代码，也的确是跳出了 RecursionError: maximum recursion depth exceeded in comparison。
之前课中做阶乘的例子，如果大于一定的整数，也是会出现递归错误，究其原因也是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层左右，我的服务就挂了。

# 以下命令的输出是？
x == y
1. 出现如下错误信息，推测原因是x与y的列表进行一项一项比较，因无限嵌套，导致递归深度失败。
   RecursionError: maximum recursion depth exceeded in comparison
2. 两个问题，需要老师解答
    既然是无限嵌套，为什么x.append(x)没有报错？
    运行len(x),结果为2,更是不可理解
  

这节没讲好，其实可以简单归纳的：
一、赋值:

在 Python 中，对象的赋值就是简单的对象引用，这点和 C++不同

 

二、浅拷贝(shallow copy):

 

浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象的引用。浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的 copy 函数。


三、深拷贝(deep copy):

深拷贝只有一种形式，copy 模块中的 deepcopy()函数。深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空间开销要高。


四、拷贝的注意点:

 

1、对于非容器类型，如数字、字符，以及其他的“原子”类型，没有拷贝一说，产生的都是原对象的引用。
2、如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝。

小结：
1. ‘==’ 用于比较值的大小，‘is’用于比较对象的内存地址是否相同，指向同一个内存地址

2. 对与整数型，范围在（-5 ~ 256 ）之间的整形数，‘==’ 与 ‘is’ 结果相同，原因在于python建立了一个数组缓存，创建对象时直接引用缓存

3. 浅拷贝：定义：重新分配一片内存，生成新的对象，里面的元素是原对象中子对象的引用。
                  生成方法： 可以通过数据构造器（list、set）完成浅拷贝，对于可变序列可以使用切片完成浅拷贝，对于元组而言，tupletuple()和切片不创建浅拷贝，指向相同元组的引用，还可以使用import copy, 使用copy.copy()来进行浅拷贝。
                浅拷贝是对元素的引用，所以对于子对象，如果子对象是不可变，没有影响，如果是可变的序列，会带来一些影响

4. 深拷贝，重新分配一块内存，创建一个新的对象，将原对象中的元素以递归的方式全部拷贝。深拷贝中会维持一个字典，记录已经拷贝的对象以及对象的ID，防止出现无限递归。

没看源码，猜的：
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'' 都是同一个，无限循环。

思考题：
一开始猜想是 print True，因为当 x append 自身的时候，程序是没有报错的，返回的结果是：[1, [...]]，我想程序既然没有报错，则 [...] 表示的应该是对应的一个最大限度的值，只是这里它没有将其表示出来；当我们 deepcopy 的时候 y 获得了同样的结果，表示深度拷贝成功；用 == 来比较两个 list 其实是比较里面的值是否相等，所以应该返回 True。

当然尝试的结果是报错 “RecursionError: maximum recursion depth exceeded in comparison”，我想应该是内部的比较函数递归比较的时候递归深度过长，也就是列表的递归嵌套超过了其限度

两个注意点，
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') # 这里地址都相同

1，没有执行代码的时候，觉得会打印True
2，执行了代码以后，如评论一样RecursionError: maximum recursion depth exceeded in comparison，递归层次过深
3，然后把代码 x.append(x) 注释掉，程序就正常返回True。也就是说问题在这行代码上。
4，网上search了一下，x.append(x)会产生一个无限嵌套列表（评论也有这么说），y深拷贝了x，也就是y拷贝了每一个x的自对象。
5，而==操作符会递归遍历对象所有值，所以出现了递归过深的错误。
不知道我的分析对不对？请老师指点

有几个问题：
1）a = 257
b = 257
print(id(a))
print(id(b))
---------
4526886832
4526886832 这个和环境有关么？我用VsCode编辑运行和jupter运行的结果不一致。juterNotebook返回的不一样的

deepcopy创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此'x == y'会无限递归对比，出现stack overflow。

实际运行：
x == y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RecursionError: maximum recursion depth exceeded in comparison

In [227]: x = [ 5678, 'abcd', ('a','b','c'), None, ['c','d'], {7899, 3333} ]

In [228]: y = copy.deepcopy(x)

In [229]: [ id(e) for e in x ]
Out[229]:
[1476285141296,
 1476287399920,
 1476279051832,
 140735866354912,
 1476285187848,
 1476267835912]

In [230]: [ id(e) for e in y ]
Out[230]:
[1476285141296,
 1476287399920,
 1476279051832,
 140735866354912,
 1476292482696,
 1476267836584]

我自己做实验的时候，发现深拷贝的时候，列表中不可变对象的元素id没有变化，只有可变对象的id发生了变化，我的理解是只有可变对象进行了重新生成，而不可变对象还是引用。
不知道我的操作有问题，还是理解有问题？