python 深拷贝 浅拷贝

# 不可变对象
import copy

number1 = 1
stringA = 'A'
turple1 = (1, 2, 3, 4, 5)

# 可变对象
dict1 = {"key": 1}
list1 = [1, 2]

# 嵌套对象
# 外层不可变 内层不可变
turple2 = (turple1, stringA)
# 外层不可变 内层可变
turple3 = (list1, dict1)
# 外层可变  内层不可变
list2 = [turple1, stringA]
# 外层可变  内层可变
list3 = [dict1, list1]

# 浅拷贝 简单对象
# 引用
# number2 = copy.copy(number1)
# print(id(number1), id(number2))
# 引用
# stringA_2 = copy.copy(stringA)
# print(id(stringA), id(stringA_2))
# 引用
# turple1_2 = copy.copy(turple1)
# print(id(turple1), id(turple1_2))
# 新对象
# dict1_2 = copy.copy(dict1)
# print(id(dict1), id(dict1_2))
# 新对象
# list1_2 = copy.copy(list1)
# print(id(list1), id(list1_2))
'''
总结： 浅拷贝 简单对象
不可变对象是引用
可变对象是新对象
'''


# 外层引用  内层引用
# turple2_2 = copy.copy(turple2)
# print(id(turple2),"--",id(turple2[0]),id(turple2[1]))
# print(id(turple2_2),"--",id(turple2_2[0]),id(turple2_2[1]))

# 外层引用  内层引用
# turple3_2 = copy.copy(turple3)
# print(id(turple3),"--",id(turple3[0]),id(turple3[1]))
# print(id(turple3_2),"--",id(turple3_2[0]),id(turple3_2[1]))

# 外层新对象 内层引用
# list2_2 = copy.copy(list2)
# print(id(list2),"--",id(list2[0]),id(list2[1]))
# print(id(list2_2),"--",id(list2_2[0]),id(list2_2[1]))

# 外层新对象 内层引用
# list3_2 = copy.copy(list3)
# print(id(list3),"--",id(list3[0]),id(list3[1]))
# print(id(list3_2),"--",id(list3_2[0]),id(list3_2[1]))

'''
总结：浅拷贝 嵌套对象
    内层都是引用，
        外层对象不可变，外层引用
        外层对象可变，外层新对象
'''

# 深拷贝 简单对象
# 引用
# number2 = copy.deepcopy(number1)
# print(id(number1), id(number2))
# 引用
# stringA_2 = copy.deepcopy(stringA)
# print(id(stringA), id(stringA_2))
# 引用
# turple1_2 = copy.deepcopy(turple1)
# print(id(turple1), id(turple1_2))
# 新对象
# dict1_2 = copy.deepcopy(dict1)
# print(id(dict1), id(dict1_2))
# 新对象
# list1_2 = copy.deepcopy(list1)
# print(id(list1), id(list1_2))
'''
总结： 深拷贝 简单对象
不可变对象是引用
可变对象是新对象
与浅拷贝结果一样
'''


# 外层引用  内层引用
# turple2_2 = copy.deepcopy(turple2)
# print(id(turple2),"--",id(turple2[0]),id(turple2[1]))
# print(id(turple2_2),"--",id(turple2_2[0]),id(turple2_2[1]))

# 外层新对象  内层新对象
# turple3_2 = copy.deepcopy(turple3)
# print(id(turple3),"--",id(turple3[0]),id(turple3[1]))
# print(id(turple3_2),"--",id(turple3_2[0]),id(turple3_2[1]))

# 外层新对象 内层引用
# list2_2 = copy.deepcopy(list2)
# print(id(list2),"--",id(list2[0]),id(list2[1]))
# print(id(list2_2),"--",id(list2_2[0]),id(list2_2[1]))

# 外层新对象 内层新对象
# list3_2 = copy.deepcopy(list3)
# print(id(list3),"--",id(list3[0]),id(list3[1]))
# print(id(list3_2),"--",id(list3_2[0]),id(list3_2[1]))

'''
总结：深拷贝 嵌套对象
    内层是可变对象，内外层都是新对象，
    内层是不可变对象，内层都是引用
        此时
        外层对象不可变，外层引用
        外层对象可变，外层新对象
'''
'''
综上：
浅拷贝 
    简单对象
        不可变对象是引用
        可变对象是新对象
    嵌套对象
        内层都是引用，
        外层对象不可变，外层引用
        外层对象可变，外层新对象
        
深拷贝 
    简单对象
        不可变对象是引用
        可变对象是新对象
    嵌套对象
        内层是可变对象，内外层都是新对象，
        内层是不可变对象，内层都是引用
            此时
            外层对象不可变，外层引用
            外层对象可变，外层新对象
        
简单对象不受copy，deepcopy的影响，
不可变对象结果都是引用
可变对象结果都是新对象

对于嵌套对象
copy不是递归处理的，因为内层都是引用，没有递归到简单对象
152 的处理逻辑
外层可以当做简单对象理解,可变对象深拷贝，不可变引用

deepcopy递归处理，受到内层对象影响
        内层可变，内外层都是深拷贝（即使外层不可变）
        内层不可变，内层引用
            此时外层按照简单对象处理
        



'''