人生苦短，我用python。

一、拷贝

1、is、==

# is 是比较两个引用是否指向了同一个对象（引用比较）。
# == 是比较两个对象是否相等。

a = [1,2,3]
b = a 
c = [1,2,3]

print(a is b)  # True
print(a == b)  # True
print(a is c)  # False
print(a == c)  # True

2、赋值

# 赋值，是对象的引用，内存id始终和原对象一致

import copy

a = 1
b = a
print(id(a))  # 1465861776
print(id(b))  # 1465861776
a=2  
print(a)  # 2
print(b)  # 1

a = [11, 22, 33]
b = a
print(id(a))  # 86832872
print(id(b))  # 86832872
a.append(44)  
print(a)  # [11, 22, 33, 44]
print(b)  # [11, 22, 33, 44]

3、浅拷贝

原子对象（数字、字符串）其实没有拷贝，产生的都是对原对象的引用。
组合对象（列表、字典、集合、元组）才有浅拷贝和深拷贝。

# 浅拷贝，是对于一个对象的顶层拷贝，拷贝了引用，并没有拷贝内容

import copy

# 情况1：
a = (11,22,33)  # 原对象是不可变类型
b = copy.copy(a)  # 浅拷贝不可变类型，内存id和原对象相同
print(id(a))  # 67342864
print(id(b))  # 67342864

# 情况2：
a = [11,22,33]  # 原对象是可变类型，包含不可变子元素
b = copy.copy(a)  # 浅拷贝可变类型，内存id和原对象不同，不可变子元素id却和原对象相同
print(id(a))  # 86683480
print(id(b))  # 86834392
a.append(44)  # 改变原对象
print(a)  # [11, 22, 33, 44]
print(b)  # [11, 22, 33]  

# 情况3：
a = (11,22,33)
b = [1,2,3]
c = (a,b)  # 原对象是可变类型，包含可变子对象
e = copy.copy(c)  # 浅拷贝可变类型，内存id和原对象不同，子对象id也和原对象相同
print(id(c))  # 67455176
print(id(e))  # 67455176  
b.append(4)  # 改变原对象，打印结果不变（这里与深拷贝不同）
print(c)  # ((11, 22, 33), [1, 2, 3, 4])
print(e)  # ((11, 22, 33), [1, 2, 3, 4])

4、深拷贝

# 深拷贝，是对于一个对象所有层次的拷贝(递归)

import copy

# 情况1：
a = (11,22,33)  # 原对象是不可变类型
b = copy.deepcopy(a)  # 深拷贝不可变类型，内存id和原对象相同
print(id(a))  # 22147160
print(id(b))  # 22147160

# 情况2：
a = [11,22,33]  # 原对象是可变类型，包含不可变子元素
b = copy.deepcopy(a)  # 深拷贝可变类型，内存id和原对象不同，不可变子元素id却和原对象相同
print(id(a))  # 86885520
print(id(b))  # 86885480
a.append(44)  # 改变原对象
print(a)  # [11, 22, 33, 44]
print(b)  # [11, 22, 33]

# 情况3：
a = (11,22,33)
b = [1,2,3]
c = (a,b)  # 原对象是可变类型，包含可变子对象
e = copy.deepcopy(c)  # 深拷贝可变类型，内存id和原对象不同，子对象id也和原对象不同
print(id(c))  # 67296432
print(id(e))  # 67466264
b.append(4)  # 改变原对象，打印结果改变（这里与浅拷贝不同）
print(c)  # ((11, 22, 33), [1, 2, 3, 4])
print(e)  # ((11, 22, 33), [1, 2, 3])