Python中的浅拷贝与深拷贝

1.浅拷贝

• 分析浅拷贝时，需要分成两种情况来讨论：
  • 情况1：如果最外层的数据类型是可变对象(列表、字典、集合等)，使用浅拷贝时会开辟新的地址去存放。
  • 情况2：如果最外层的数据类型是不可变对象(字符串、数字、元组等)，使用浅拷贝时不会开辟新的地址空间。
• 情况1的实例如下：

  import copy
  
  a = [1, 2]
  b = [3, 4]
  c = [a, b]   # 注意这里的c就是一个可变对象！
  d = copy.copy(c)
  
  print("变量c:", c)
  print("变量c在内存中的地址:",id(c))
  print("变量a在内存中的地址:",id(a))
  print("变量b在内存中的地址:",id(b))
  print("----------------------------------")
  print("变量d:", d)
  print("变量d在内存中的地址:",id(d))
  print("变量d[0]在内存中的地址:",id(d[0]))
  print("变量d[1]在内存中的地址:",id(d[1]))
  

• 结果：

  变量c: [[1, 2], [3, 4]]
  变量c在内存中的地址: 43949256
  变量a在内存中的地址: 43990920
  变量b在内存中的地址: 43949192
  ----------------------------------
  变量d: [[1, 2], [3, 4]]
  变量d在内存中的地址: 43988488
  变量d[0]在内存中的地址: 43990920
  变量d[1]在内存中的地址: 43949192
  

• 原因分析：需要拷贝的对象c是一个list，即可变对象。因为c的最外层是[a,b]。因此在执行浅拷贝时，仅仅把最外层拷贝过来，而里面的值没有拷贝过来。
• 情况2的实例如下：

  import copy
  
  a = [1, 2]
  b = [3, 4]
  c = (a, b)  # 注意这里的c就是一个不可变对象！
  d = copy.copy(c)
  
  print("变量c:", c)
  print("变量c在内存中的地址:",id(c))
  print("变量a在内存中的地址:",id(a))
  print("变量b在内存中的地址:",id(b))
  print("----------------------------------")
  print("变量d:", d)
  print("变量d在内存中的地址:",id(d))
  print("变量d[0]在内存中的地址:",id(d[0]))
  print("变量d[1]在内存中的地址:",id(d[1]))
  

• 结果：

  变量c: ([1, 2], [3, 4])
  变量c在内存中的地址: 42186696
  变量a在内存中的地址: 42286984
  变量b在内存中的地址: 42245256
  ----------------------------------
  变量d: ([1, 2], [3, 4])
  变量d在内存中的地址: 42186696
  变量d[0]在内存中的地址: 42286984
  变量d[1]在内存中的地址: 42245256
  

• 原因分析：因为c = (a,b)，c是一个元组tuple，即c的最外层是一个不可变对象。当d在进行浅拷贝操作时，直接引用c的地址，不会再为d开辟新的地址空间。

2.深拷贝

• 分析深拷贝时，需要分成:三种情况来讨论：
  • 情况1：如果最外层的数据类型是可变对象(列表、字典、集合等)，使用深拷贝时，内部和外部的数据都会被拷贝过来。
  • 情况2：如果最外层的数据类型是不可变对象(字符串、数字、元组等)，但内部的数据类型是可变对象时。使用深拷贝时，会开辟新的地址空间。
  • 情况3：如果最外层的数据类型是不可变对象(字符串、数字、元组等)，内部的数据类型也是不可变对象时，和浅拷贝的第二种情况一样，不会开辟新的地址空间，是对原始数据对象的引用。
• 情况1实例如下：

  import copy
  
  a = [1, 2]  # a是可变对象
  b = copy.deepcopy(a)
  
  print("变量a:", a)
  print("变量a在内存中的地址:",id(a))
  print("----------------------------------")
  print("变量b:", b)
  print("变量b在内存中的地址:",id(b))
  

• 结果：

  变量a: [1, 2]
  变量a在内存中的地址: 43925384
  ----------------------------------
  变量b: [1, 2]
  变量b在内存中的地址: 43883656
  

• 原因分析：由于最外层是可变对象list，因此对a进行深拷贝会开辟一个新的地址空间，修改a的值，不会影响b
• 情况2实例如下：

  import copy
  
  a = [1, 2]
  b = [3, 4]
  c = (a, b)     # 注意这里外层的c就是一个不可变对象！但是里面的a和b都是可变对象！
  d = copy.deepcopy(c)
  
  print("变量c:", c)
  print("变量c在内存中的地址:",id(c))
  print("变量a在内存中的地址:",id(a))
  print("变量b在内存中的地址:",id(b))
  print("----------------------------------")
  print("变量d:", d)
  print("变量d在内存中的地址:",id(d))
  print("变量d[0]在内存中的地址:",id(d[0]))
  print("变量d[1]在内存中的地址:",id(d[1]))
  

• 结果：

  变量c: ([1, 2], [3, 4])
  变量c在内存中的地址: 40729736
  变量a在内存中的地址: 40845192
  变量b在内存中的地址: 40803464
  ----------------------------------
  变量d: ([1, 2], [3, 4])
  变量d在内存中的地址: 40803080
  变量d[0]在内存中的地址: 40845256
  变量d[1]在内存中的地址: 40842760
  

• 原因分析：因为最外层的c是一个元组，不可变对象。但是里面的数据a和b是两个list可变对象。因此在深拷贝时，是会开辟新的地址空间的。
• 情况3实例如下：

  import copy
  
  a = (1, 2)
  b = (3, 4)
  c = (a, b)  # 注意这里外层的c就是一个不可变对象！但是里面的a和b也都是不可变对象！
  d = copy.deepcopy(c)
  
  print("变量c:", c)
  print("变量c在内存中的地址:",id(c))
  print("变量a在内存中的地址:",id(a))
  print("变量b在内存中的地址:",id(b))
  print("----------------------------------")
  print("变量d:", d)
  print("变量d在内存中的地址:",id(d))
  print("变量d[0]在内存中的地址:",id(d[0]))
  print("变量d[1]在内存中的地址:",id(d[1]))
  

• 结果：

  变量c: ((1, 2), (3, 4))
  变量c在内存中的地址: 41129928
  变量a在内存中的地址: 41072904
  变量b在内存中的地址: 41130632
  ----------------------------------
  变量d: ((1, 2), (3, 4))
  变量d在内存中的地址: 41129928
  变量d[0]在内存中的地址: 41072904
  变量d[1]在内存中的地址: 41130632
  

• 原因分析：因为c = (a,b)，c是一个元组tuple，即c的最外层是一个不可变对象；同时，里面的a和b也是元组对象，不可变对象。当d在进行深拷贝操作时，直接引用c的地址，不会再为d开辟新的地址空间，与浅拷贝的第二种情况一样。