2. 17、人工智能Python基础之彻底搞懂赋值、浅拷贝、深拷贝的区别_笔记
    5. # 可变对象与不可变对象
    6. # 可变对象的可变性实质上是指 更改可变对象中的子对象 比如list中的item对象
    9. # 不可变对象：string tuple number
    10. # 可变对象：列表 字典
    13. # 可变对象与不可变对象的赋值有区别：
    14. # 不可变对象进行重新赋值的时候，实际上是将原始值丢弃，将变量指向一个新值，一个新的内存地址
    15. # 可变对象的赋值就是创建了对象的一个新的引用(别名)，并不开辟一个新的内存空间
    17. # 浅拷贝与深拷贝只针对可变对象
    20. # 浅拷贝：只拷贝父对象，不拷贝子对象
    21. # 只拷贝了最外围的对象本身，内部的子对象都只是拷贝了一个引用而已
    22. # 浅拷贝：创建一个新的父对象，但它包含的是对原始对象中所有子项的引用，如果用引用的方式修改其中一个对象，另外一个也会改变
    23. # 常见操作：列表的切片[:]操作、使用工厂函数如list/dir/set操作，对象的copy()函数、copy模块的copy()函数（两个一模一样的双胞胎）
    25. # 深拷贝：会拷贝父对象和子对象并且递归的方式拷贝所有的子对象，当对象子对象进行更改的时候，原始对象不会改变。
    26. # 常见操作：copy模块的deepcopy()函数
    27. # 深拷贝不是拷贝子对象的引用 而是拷贝了数据结构
    30. # -*- coding: utf-8 -*-
    31. __author__ = 'dongfangyao'
    32. __date__ = '2018/1/15 下午11:07'
    33. __product__ = 'PyCharm'
    34. __filename__ = 'copy1'
    36. import copy
    37. # 赋值 浅拷贝 深拷贝
    38. # python 可变对象list dict  不可变对象 string tuple number
    40. # str1 = 'dfy'
    41. # print(id(str1))
    42. # str1 = 'dongfangyao'
    43. # print(id(str1))
    44. #
    45. # a = [1, 2, 3]
    46. # a1 = a
    47. # print(id(a))
    48. # print(id(a1))
    49. # a[1] = 22
    50. # print(a)
    51. # print(a1)
    53. # 浅拷贝
    54. # [:] list() set()  copy.copy()  list.copy()
    55. a = [1, 2, 3]
    56. b = [11, 22, 33]
    57. c = [111, 222, 333]
    58. list1 = [a, b, c]
    59. print('list1的内存地址：' + str(id(list1)))
    61. print('_'*20)
    62. list2 = list1
    63. # print(id(list1) == id(list2))
    65. list3 = list1[:]
    66. # print(id(list1) == id(list3))
    67. # print(id(list1[0][1]) == id(list3[0][1]))
    69. # a[0] = 1111
    70. # list1[0] = 'dfy'
    71. # list1[1][0] = '1111'
    72. # print(list1)
    73. # print(list3)
    74. # 深拷贝 copy.deepcopy()
    75. list4 = copy.deepcopy(list1)
    76. print(id(list1) == id(list4))
    77. print(id(list1[0]) == id(list4[0]))
    78. print(id(list1[0][1]) == id(list4[0][1]))
    80. # a[0] = 1111
    81. # list1[0] = 'dfy'
    82. list1[1][0] = '1111'
    83. print(list1)
    84. print(list4)
    88. 复制代码
    90. import copy
    92. list_0 = ["A", "B", ["C", "D"], "E"]
    93. list_1 = copy.copy(list_0)
    94. list_2 = list_0.copy()
    95. list_3 = list_0[:]
    96. list_4 = list(list_0)
    97. list_5 = list_0
    99. # --- 深拷贝的拷贝方式 ---
    100. list_d = copy.deepcopy(list_0)
    103. # --- 深浅拷贝与赋值的区别 ---
    104. # 1. 对第一层数据进行赋值
    105. list_0[0] = "X0"
    106. list_1[0] = "X1"
    107. list_2[0] = "X2"
    108. list_3[0] = "X3"
    109. list_4[0] = "X4"
    110. list_5[0] = "X5"
    111. list_d[0] = "Xd"
    114. # 2. 对第二层的list引用进行赋值
    115. # list_0[2][0] = "Y0"
    116. # list_1[2][0] = "Y1"
    117. # list_2[2][0] = "Y2"
    118. # list_3[2][0] = "Y3"
    119. # list_4[2][0] = "Y4"
    120. # list_5[2][0] = "Y5"
    121. # list_d[2][0] = "Yd"
    124. # 3. 对第一层数据进行赋值
    125. # list_0[3]= "Z0"
    126. # list_1[3]= "Z1"
    127. # list_2[3]= "Z2"
    128. # list_3[3]= "Z3"
    129. # list_4[3]= "Z4"
    130. # list_5[3]= "Z5"
    131. # list_d[3]= "Zd"
    133. print(list_0)
    134. print(list_1)
    135. print(list_2)
    136. print(list_3)
    137. print(list_4)
    138. print(list_5)
    139. print(list_d)
    147. lst = []
    149. a = [1]
    150. lst.append(a)
    151. a[0] = 2
    152. lst.append(a)
    153. print(id(a))
    154. print(lst)
    155. a = [3]
    156. print(id(a))
    157. lst.append(a)
    158. 复制代码
    161. 第一次是赋值给a的子对象，没有改变a的地址，然后lst中存的又是a的引用，改变了a的子对象的值，就改变了lst中存的引用的值，所以前两个输出是[2] ；
    162. 第二次赋值赋给a本身的父对象，因为一个变量同时只能指向一个内存地址的数据，所以a的地址改变了，lst中存入了一个新的引用，所以第三个的输出是[3]