import copy
"""
比较操作符'=='表示比较对象间的值是否相等，而'is'表示比较对象的标识是否相等，
即它们是否指向同一个内存地址。
比较操作符'is'效率优于'=='，因为'is'操作符无法被重载，执行'is'操作只是简单
的获取对象的 ID，并进行比较；而'=='操作符则会递归地遍历对象的所有值，并逐一比
较。
浅拷贝中的元素，是原对象中子对象的引用，因此，如果原对象中的元素是可变的，改
变其也会影响拷贝后的对象，存在一定的副作用。
深度拷贝则会递归地拷贝原对象中的每一个子对象，因此拷贝后的对象和原对象互不相
关。另外，深度拷贝中会维护一个字典，记录已经拷贝的对象及其 ID，来提高效率并防
止无限递归的发生。
"""
a = 10
b = 10

# 比较a 和 b 值是否相等，a == b，相当于执行了 a.__eq__(b)
print(f'compare the value of a and b, result:{a == b}')  # True

# 比较a 和 b 是否是同一个对象 a is b， 就是 比较两者的id是否相等
print(f'compare the object of a and b is the same, result: {a is b}')
print(f'id of a : {id(a)}')
print(f'id of b : {id(b)}')
print(f'compare the id of object a and object b, result: {id(a) == id(b)}')  # True

# 不可变的数据类型，他们在创建的时候开辟同样的内存地址
c = 12345678
d = 12345678
print(id(c))
print(id(d))
print(f'{c is d}')  # True

# 两个不可变的tuple，包含可变的list。list 发生改变，两个值不相等
t1 = (1, 2, [3, 4])
t2 = (1, 2, [3, 4])
print(t1 == t2)  # True

t1[-1].append(5)
print(t1 == t2)  # False

# 两个可变类型的id是不相等的，所以即使值一样他们的id也不一样
s1 = [1, 2, 3]
s2 = [1, 2, 3]
print(s1 == s2)  # True
print(s1 is s2)  # False

# 浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用
# 利用构造器, 切片, copy.copy()
l1 = ['a', 'b', 'c']
l2 = list(l1)
l3 = l1[:]
l4 = copy.copy(l1)
print(f'{l1 is l2}')  # False
print(f'{l1 is l3}')  # False
print(f'{l1 is l4}')  # False

# 对于元组，使用 tuple() 或者切片操作符':'不会创建一份浅拷贝，
# 相反，它会返回一个指向相同元组的引用
tuple1 = (1, 2, [3, 4, 5])
tuple2 = tuple(tuple1)

tuple2[-1].append(6)
print(tuple1)
print(f'{tuple1 is tuple2}')  # True
print(f'{tuple2 == tuple1}')  # True

# 浅拷贝的副作用，因为浅拷贝只能保证两个对象的元素的地址相同，两个对象本质上还是指向不同的内存地址
# 存在着被拷贝增加元素，拷贝对象不变，被拷贝对象的元素是tuple，发生改变，拷贝对象不变的情况
l1 = [[1, 2], (30, 40)]
l2 = list(l1)
l1.append(100)
l1[0].append(3)
print(l1)
# [[1, 2, 3], (30, 40), 100]
print(l2)
# [[1, 2, 3], (30, 40)]
l1[1] += (50, 60)
print(l1)
# [[1, 2, 3], (30, 40, 50, 60), 100]
print(l2)
# [[1, 2, 3], (30, 40)]

# 深拷贝 是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递
# 归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联
l1 = [[1, 2], (30, 40)]
l2 = copy.deepcopy(l1)
l1.append(100)
l1[0].append(3)

print(l1)  # [[1, 2, 3], (30, 40), 100]
print(l2)  # [[1, 2], (30, 40)]

# 深拷贝的缺陷：如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环：
x = [1]
x.append(x)

print(x)
# 实际情况程序并不会崩溃，记录已经拷贝的对象与其ID。
# 拷贝过程中，如果字典里已经存储了将要拷贝的对象，则会从字典直接返回
y = copy.deepcopy(x)
print(y)

print(f'{x == y}')
# print(f'{x is y}')