import copy

original_list = [1, [2, 3], {'a': 4}]
shallow_copied = copy.copy(original_list)

# 修改淺拷貝后的對象
shallow_copied[0] = 100       # 不影響原對象
shallow_copied[1][0] = 200    # 會影響原對象

import copy

original_dict = {'a': [1, 2], 'b': {'c': 3}}
deep_copied = copy.deepcopy(original_dict)

# 修改深拷貝后的對象
deep_copied['a'][0] = 100    # 不影響原對象
deep_copied['b']['c'] = 300  # 不影響原對象

class MyClass:
    def __init__(self, x):
        self.x = x
    
    def __copy__(self):
        print("執(zhí)行淺拷貝")
        return MyClass(self.x)
    
    def __deepcopy__(self, memo):
        print("執(zhí)行深拷貝")
        return MyClass(copy.deepcopy(self.x, memo))

obj = MyClass([1,2,3])
copy.copy(obj)      # 輸出：執(zhí)行淺拷貝
copy.deepcopy(obj)  # 輸出：執(zhí)行深拷貝

# 使用memo字典避免重復拷貝（深拷貝優(yōu)化）
memo = {}
deep_copied = copy.deepcopy(big_object, memo)

# 對于不可變對象，直接引用而非拷貝
from copy import copy, deepcopy
immutable_types = (int, float, str, tuple, frozenset)

def smart_copy(obj):
    if isinstance(obj, immutable_types):
        return obj
    return deepcopy(obj)

a = [1]
b = [2]
a.append(b)
b.append(a)  # 創(chuàng)建循環(huán)引用

# 普通深拷貝會棧溢出
safe_copy = copy.deepcopy(a)  # 自動處理循環(huán)引用

import threading
lock = threading.Lock()

# 深拷貝會跳過線程鎖等特殊對象
lock_copy = copy.deepcopy(lock)  # 返回原鎖的引用

# 測試10000個元素的列表
淺拷貝耗時：0.0023s
深拷貝耗時：0.0158s

# 使用生成器表達式減少內(nèi)存占用
large_list = [x for x in range(100000)]
memory_efficient_copy = list(x for x in large_list)