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开辟新的地址空间，与浅拷贝的第二种情况一样。