• python 深拷贝 浅拷贝


      1 # 不可变对象
      2 import copy
      3 
      4 number1 = 1
      5 stringA = 'A'
      6 turple1 = (1, 2, 3, 4, 5)
      7 
      8 # 可变对象
      9 dict1 = {"key": 1}
     10 list1 = [1, 2]
     11 
     12 # 嵌套对象
     13 # 外层不可变 内层不可变
     14 turple2 = (turple1, stringA)
     15 # 外层不可变 内层可变
     16 turple3 = (list1, dict1)
     17 # 外层可变  内层不可变
     18 list2 = [turple1, stringA]
     19 # 外层可变  内层可变
     20 list3 = [dict1, list1]
     21 
     22 # 浅拷贝 简单对象
     23 # 引用
     24 # number2 = copy.copy(number1)
     25 # print(id(number1), id(number2))
     26 # 引用
     27 # stringA_2 = copy.copy(stringA)
     28 # print(id(stringA), id(stringA_2))
     29 # 引用
     30 # turple1_2 = copy.copy(turple1)
     31 # print(id(turple1), id(turple1_2))
     32 # 新对象
     33 # dict1_2 = copy.copy(dict1)
     34 # print(id(dict1), id(dict1_2))
     35 # 新对象
     36 # list1_2 = copy.copy(list1)
     37 # print(id(list1), id(list1_2))
     38 '''
     39 总结: 浅拷贝 简单对象
     40 不可变对象是引用
     41 可变对象是新对象
     42 '''
     43 
     44 
     45 # 外层引用  内层引用
     46 # turple2_2 = copy.copy(turple2)
     47 # print(id(turple2),"--",id(turple2[0]),id(turple2[1]))
     48 # print(id(turple2_2),"--",id(turple2_2[0]),id(turple2_2[1]))
     49 
     50 # 外层引用  内层引用
     51 # turple3_2 = copy.copy(turple3)
     52 # print(id(turple3),"--",id(turple3[0]),id(turple3[1]))
     53 # print(id(turple3_2),"--",id(turple3_2[0]),id(turple3_2[1]))
     54 
     55 # 外层新对象 内层引用
     56 # list2_2 = copy.copy(list2)
     57 # print(id(list2),"--",id(list2[0]),id(list2[1]))
     58 # print(id(list2_2),"--",id(list2_2[0]),id(list2_2[1]))
     59 
     60 # 外层新对象 内层引用
     61 # list3_2 = copy.copy(list3)
     62 # print(id(list3),"--",id(list3[0]),id(list3[1]))
     63 # print(id(list3_2),"--",id(list3_2[0]),id(list3_2[1]))
     64 
     65 '''
     66 总结:浅拷贝 嵌套对象
     67     内层都是引用,
     68         外层对象不可变,外层引用
     69         外层对象可变,外层新对象
     70 '''
     71 
     72 # 深拷贝 简单对象
     73 # 引用
     74 # number2 = copy.deepcopy(number1)
     75 # print(id(number1), id(number2))
     76 # 引用
     77 # stringA_2 = copy.deepcopy(stringA)
     78 # print(id(stringA), id(stringA_2))
     79 # 引用
     80 # turple1_2 = copy.deepcopy(turple1)
     81 # print(id(turple1), id(turple1_2))
     82 # 新对象
     83 # dict1_2 = copy.deepcopy(dict1)
     84 # print(id(dict1), id(dict1_2))
     85 # 新对象
     86 # list1_2 = copy.deepcopy(list1)
     87 # print(id(list1), id(list1_2))
     88 '''
     89 总结: 深拷贝 简单对象
     90 不可变对象是引用
     91 可变对象是新对象
     92 与浅拷贝结果一样
     93 '''
     94 
     95 
     96 # 外层引用  内层引用
     97 # turple2_2 = copy.deepcopy(turple2)
     98 # print(id(turple2),"--",id(turple2[0]),id(turple2[1]))
     99 # print(id(turple2_2),"--",id(turple2_2[0]),id(turple2_2[1]))
    100 
    101 # 外层新对象  内层新对象
    102 # turple3_2 = copy.deepcopy(turple3)
    103 # print(id(turple3),"--",id(turple3[0]),id(turple3[1]))
    104 # print(id(turple3_2),"--",id(turple3_2[0]),id(turple3_2[1]))
    105 
    106 # 外层新对象 内层引用
    107 # list2_2 = copy.deepcopy(list2)
    108 # print(id(list2),"--",id(list2[0]),id(list2[1]))
    109 # print(id(list2_2),"--",id(list2_2[0]),id(list2_2[1]))
    110 
    111 # 外层新对象 内层新对象
    112 # list3_2 = copy.deepcopy(list3)
    113 # print(id(list3),"--",id(list3[0]),id(list3[1]))
    114 # print(id(list3_2),"--",id(list3_2[0]),id(list3_2[1]))
    115 
    116 '''
    117 总结:深拷贝 嵌套对象
    118     内层是可变对象,内外层都是新对象,
    119     内层是不可变对象,内层都是引用
    120         此时
    121         外层对象不可变,外层引用
    122         外层对象可变,外层新对象
    123 '''
    124 '''
    125 综上:
    126 浅拷贝 
    127     简单对象
    128         不可变对象是引用
    129         可变对象是新对象
    130     嵌套对象
    131         内层都是引用,
    132         外层对象不可变,外层引用
    133         外层对象可变,外层新对象
    134         
    135 深拷贝 
    136     简单对象
    137         不可变对象是引用
    138         可变对象是新对象
    139     嵌套对象
    140         内层是可变对象,内外层都是新对象,
    141         内层是不可变对象,内层都是引用
    142             此时
    143             外层对象不可变,外层引用
    144             外层对象可变,外层新对象
    145         
    146 简单对象不受copy,deepcopy的影响,
    147 不可变对象结果都是引用
    148 可变对象结果都是新对象
    149 
    150 对于嵌套对象
    151 copy不是递归处理的,因为内层都是引用,没有递归到简单对象
    152 的处理逻辑
    153 外层可以当做简单对象理解,可变对象深拷贝,不可变引用
    154 
    155 deepcopy递归处理,受到内层对象影响
    156         内层可变,内外层都是深拷贝(即使外层不可变)
    157         内层不可变,内层引用
    158             此时外层按照简单对象处理
    159         
    160 
    161 
    162 
    163 '''
  • 相关阅读:
    命名空间“Microsoft”中不存在类型或命名空间名“Reporting”(是否缺少程序集引用?)
    VS2017按F1使用中文帮助
    SQL Server重建所有表索引
    SQL Server行列转换
    GitHub笔记---邮箱访问错误
    C学习笔记(8)--- 文件读写
    C学习笔记(7)--- typedef,输入输出
    C学习笔记(6)--- 共用体,位域深入
    C学习笔记(5)--- 指针第二部分,字符串,结构体。
    C学习笔记(4)--- 指针的应用(第一部分)
  • 原文地址:https://www.cnblogs.com/huaida/p/15779697.html
Copyright © 2020-2023  润新知