目录
深拷贝deepcopy
在使用 deepcopy 时，有一些常见的容易弄错的例子。deepcopy 会递归地复制一个对象及其所有子对象，这样就可以创建一个完全独立的副本。以下是几个常见的错误和误解，以及相应的示例：
示例1：修改原始对象不会影响深拷贝
import copy
original = [1, [2, 3], 4]
deep_copied = copy.deepcopy(original)
original[1][0] = 'changed'
print("Original:", original) # Output: [1, ['changed', 3], 4]
print("Deep Copied:", deep_copied) # Output: [1, [2, 3], 4]
容易弄错的点：有些人可能会误以为修改原始对象的子对象会影响深拷贝的对象，但实际上深拷贝对象是完全独立的。
示例2：浅拷贝 vs 深拷贝
import copy
original = [1, [2, 3], 4]
shallow_copied = copy.copy(original)
deep_copied = copy.deepcopy(original)
original[1][0] = 'changed'
print("Original:", original) # Output: [1, ['changed', 3], 4]
print("Shallow Copied:", shallow_copied) # Output: [1, ['changed', 3], 4]
print("Deep Copied:", deep_copied) # Output: [1, [2, 3], 4]
容易弄错的点：浅拷贝（copy.copy）只复制了最外层对象，内部的子对象还是引用原来的对象。而深拷贝（copy.deepcopy）会复制所有层次的对象。
示例3：深拷贝可能会引发递归错误
import copy
original = [1, 2, 3]
original.append(original)
try:
deep_copied = copy.deepcopy(original)
except RecursionError as e:
print("RecursionError:", e)
容易弄错的点：如果对象包含自引用，使用深拷贝时需要特别小心，可能会引发无限递归错误。
示例4：深拷贝带来的性能问题
深拷贝由于需要复制所有子对象，可能会带来性能开销，特别是对于大对象。
import copy
import time
large_list = [list(range(1000)) for _ in range(1000)]
start_time = time.time()
deep_copied = copy.deepcopy(large_list)
end_time = time.time()
print("Time taken for deepcopy:", end_time - start_time)
容易弄错的点：深拷贝会比浅拷贝或者直接引用带来更大的性能开销，对于大对象需要注意这一点。
总结
使用 deepcopy 时，确保了解其行为和潜在的问题，特别是在处理复杂的嵌套对象、自引用对象以及性能敏感的场景时。
list拷贝copy有坑
import copy
if __name__ == '__main__':
original_list = [1, 2, 3, 4, 5]
copied_list = copy.copy(original_list)
copied_list[0]=10
print(original_list)
original_list = [[1, 2, 3, 4, 5]]
copied_list = copy.copy(original_list)
copied_list[0][0]=10
print(original_list)如果list内单纯的数字，是可以的，如果list是二维，或者多维，就有坑
示例1：浅拷贝只复制最外层对象
import copy
original = [1, [2, 3], 4]
shallow_copied = copy.copy(original)
original[1][0] = 'changed'
print("Original:", original) # Output: [1, ['changed', 3], 4]
print("Shallow Copied:", shallow_copied) # Output: [1, ['changed', 3], 4]
示例2：浅拷贝对不可变对象的影响
import copy
original = (1, 2, 3)
shallow_copied = copy.copy(original)
# 由于元组是不可变的，shallow_copied 和 original 指向同一个对象
print("Original is shallow_copied:", original is shallow_copied) # Output: True
示例3：深拷贝和自引用对象
import copy
original = [1, 2, 3]
original.append(original)
try:
deep_copied = copy.deepcopy(original)
except RecursionError as e:
print("RecursionError:", e)
示例4：浅拷贝和深拷贝的性能差异
import copy
import time
large_list = [list(range(1000)) for _ in range(1000)]
start_time = time.time()
shallow_copied = copy.copy(large_list)
end_time = time.time()
print("Time taken for shallow copy:", end_time - start_time)
start_time = time.time()
deep_copied = copy.deepcopy(large_list)
end_time = time.time()
print("Time taken for deep copy:", end_time - start_time)
示例5：字典的浅拷贝
import copy
original = {'a': 1, 'b': [2, 3]}
shallow_copied = copy.copy(original)
original['b'][0] = 'changed'
print("Original:", original) # Output: {'a': 1, 'b': ['changed', 3]}
print("Shallow Copied:", shallow_copied) # Output: {'a': 1, 'b': ['changed', 3]}
示例6：使用浅拷贝修改函数默认参数
import copy
def append_element(lst=None):
if lst is None:
lst = []
else:
lst = copy.copy(lst)
lst.append(1)
return lst
default_list = [0]
print(append_element(default_list)) # Output: [0, 1]
print(append_element(default_list)) # Output: [0, 1] # Expected [0] due to shallow copy
容易弄错的点：在函数中使用浅拷贝复制默认参数时，原始对象会被修改，而不是创建一个新的独立对象。如果期望完全独立的对象，应该使用深拷贝。
