# 理解Python的引用機制
a = [1, 2, 3]  # a是列表對象的引用
b = a         # b是同一個列表對象的另一個引用

print(f"a: {a}, id: {id(a)}")
print(f"b: {b}, id: {id(b)}")
print(f"a is b: {a is b}")  # 它們指向同一個對象

# 修改通過a引用的對象
a.append(4)
print(f"\n修改後:")
print(f"a: {a}")
print(f"b: {b}")  # b也"看到"了變化
print(f"a is b: {a is b}")

# 不可變對象示例
x = 10
y = x  # y和x指向同一個整數對象
print(f"x: {x}, id: {id(x)}")
print(f"y: {y}, id: {id(y)}")
print(f"x is y: {x is y}")

# 嘗試"修改"不可變對象
x += 1  # 實際上創建了新對象
print(f"\n'修改'後:")
print(f"x: {x}, id: {id(x)}")  # id改變了
print(f"y: {y}, id: {id(y)}")  # y不變
print(f"x is y: {x is y}")

# 可變對象示例
list1 = [1, 2, 3]
list2 = list1  # 引用傳遞
list1.append(4)
print(f"\n可變對象:")
print(f"list1: {list1}, id: {id(list1)}")
print(f"list2: {list2}, id: {id(list2)}")  # list2也改變了
print(f"list1 is list2: {list1 is list2}")

def demonstrate_references():
    """演示引用與對象標識"""
    
    # 簡單對象
    a = 42
    b = 42  # Python會緩存小整數，所以a和b可能引用同一個對象
    print(f"整數:")
    print(f"  a = 42, id: {id(a)}")
    print(f"  b = 42, id: {id(b)}")
    print(f"  a is b: {a is b}")
    
    # 列表對象
    list1 = [1, 2, 3]
    list2 = [1, 2, 3]  # 兩個不同的列表對象
    print(f"\n列表:")
    print(f"  list1 = [1, 2, 3], id: {id(list1)}")
    print(f"  list2 = [1, 2, 3], id: {id(list2)}")
    print(f"  list1 is list2: {list1 is list2}")
    print(f"  list1 == list2: {list1 == list2}")  # 內容相等但不是同一個對象
    
    # 字符串（不可變）
    str1 = "hello"
    str2 = "hello"  # Python會緩存字符串字面量
    str3 = "hello" + "!"  # 創建新字符串
    print(f"\n字符串:")
    print(f"  str1 = 'hello', id: {id(str1)}")
    print(f"  str2 = 'hello', id: {id(str2)}")
    print(f"  str3 = 'hello!', id: {id(str3)}")
    print(f"  str1 is str2: {str1 is str2}")
    print(f"  str1 is str3: {str1 is str3}")

demonstrate_references()

# 使用切片操作實現淺拷貝
original = [1, 2, 3, [4, 5]]
shallow_copy = original[:]  # 切片創建淺拷貝

print("=== 淺拷貝示例 ===")
print(f"原始列表: {original}, id: {id(original)}")
print(f"淺拷貝: {shallow_copy}, id: {id(shallow_copy)}")
print(f"original is shallow_copy: {original is shallow_copy}")

# 修改外層元素
original[0] = 100
print(f"\n修改外層元素 original[0] = 100:")
print(f"原始列表: {original}")
print(f"淺拷貝: {shallow_copy}")  # 淺拷貝不受影響

# 修改內層嵌套列表
original[3].append(6)
print(f"\n修改內層嵌套列表 original[3].append(6):")
print(f"原始列表: {original}")
print(f"淺拷貝: {shallow_copy}")  # 淺拷貝的內層列表也改變了！
print(f"original[3] is shallow_copy[3]: {original[3] is shallow_copy[3]}")

import copy

def demonstrate_shallow_copy_methods():
    """演示不同的淺拷貝方法"""
    
    original = [1, 2, 3, ['a', 'b']]
    
    print("=== 不同的淺拷貝方法 ===")
    
    # 方法1：列表切片
    copy1 = original[:]
    print(f"1. 切片: original[:]")
    print(f"   原始id: {id(original)}, 拷貝id: {id(copy1)}")
    print(f"   original is copy1: {original is copy1}")
    
    # 方法2：list()構造函數
    copy2 = list(original)
    print(f"\n2. list()構造函數: list(original)")
    print(f"   原始id: {id(original)}, 拷貝id: {id(copy2)}")
    print(f"   original is copy2: {original is copy2}")
    
    # 方法3：copy模塊的copy()函數
    copy3 = copy.copy(original)
    print(f"\n3. copy.copy(): copy.copy(original)")
    print(f"   原始id: {id(original)}, 拷貝id: {id(copy3)}")
    print(f"   original is copy3: {original is copy3}")
    
    # 方法4：字典的copy()方法（針對字典）
    original_dict = {'a': 1, 'b': [2, 3]}
    dict_copy = original_dict.copy()
    print(f"\n4. dict.copy(): original_dict.copy()")
    print(f"   原始id: {id(original_dict)}, 拷貝id: {id(dict_copy)}")
    print(f"   original_dict is dict_copy: {original_dict is dict_copy}")
    
    # 方法5：集合的copy()方法
    original_set = {1, 2, 3}
    set_copy = original_set.copy()
    print(f"\n5. set.copy(): original_set.copy()")
    print(f"   原始id: {id(original_set)}, 拷貝id: {id(set_copy)}")
    print(f"   original_set is set_copy: {original_set is set_copy}")
    
    # 驗證所有淺拷貝都共享內層對象
    print(f"\n=== 驗證內層對象共享 ===")
    print(f"修改 original[3].append('c') 後:")
    original[3].append('c')
    print(f"  original: {original}")
    print(f"  copy1: {copy1}")
    print(f"  copy2: {copy2}")
    print(f"  copy3: {copy3}")
    
    return original, copy1, copy2, copy3

original, *copies = demonstrate_shallow_copy_methods()

def shallow_copy_use_cases():
    """淺拷貝的適用場景"""
    
    print("=== 淺拷貝適用場景 ===")
    
    # 場景1：創建對象的獨立副本，但內部引用不變是可以接受的
    print("\n1. 創建配置模板:")
    default_config = {
        'debug': False,
        'timeout': 30,
        'retries': 3,
        'headers': {'User-Agent': 'MyApp/1.0'}
    }
    
    # 為不同請求創建配置副本
    config1 = default_config.copy()
    config2 = default_config.copy()
    
    config1['debug'] = True  # 修改獨立配置
    config1['timeout'] = 60
    
    print(f"   default_config: {default_config}")
    print(f"   config1: {config1}")
    print(f"   config2: {config2}")
    
    # 注意：headers字典是共享的！
    config1['headers']['User-Agent'] = 'MyApp/2.0'
    print(f"\n   修改headers後:")
    print(f"   default_config headers: {default_config['headers']}")
    print(f"   config1 headers: {config1['headers']}")
    print(f"   config2 headers: {config2['headers']}")
    
    # 場景2：避免循環中意外修改原數據
    print("\n2. 循環中保護原數據:")
    students = [
        {'name': 'Alice', 'scores': [85, 90]},
        {'name': 'Bob', 'scores': [78, 82]}
    ]
    
    # 錯誤方式：直接使用原對象
    processed_wrong = []
    for student in students:
        student_copy = student  # 這只是引用，不是拷貝！
        student_copy['average'] = sum(student['scores']) / len(student['scores'])
        processed_wrong.append(student_copy)
    
    print(f"   錯誤方式處理後:")
    print(f"   原students被修改: {students}")
    
    # 正確方式：使用淺拷貝
    students = [  # 恢復原數據
        {'name': 'Alice', 'scores': [85, 90]},
        {'name': 'Bob', 'scores': [78, 82]}
    ]
    
    processed_correct = []
    for student in students:
        student_copy = student.copy()  # 淺拷貝
        student_copy['average'] = sum(student['scores']) / len(student['scores'])
        processed_correct.append(student_copy)
    
    print(f"\n   正確方式處理後:")
    print(f"   原students未被修改: {students}")
    print(f"   處理結果: {processed_correct}")
    
    # 但仍然存在的問題：scores列表是共享的
    processed_correct[0]['scores'].append(95)
    print(f"\n   注意：scores列表仍然是共享的")
    print(f"   students[0]['scores']: {students[0]['scores']}")
    
    return default_config, students, processed_correct

shallow_copy_use_cases()

import copy

def demonstrate_deep_copy():
    """演示深拷貝"""
    
    print("=== 深拷貝示例 ===")
    
    # 嵌套數據結構
    original = [
        1,
        [2, 3],
        {'a': 4, 'b': [5, 6]},
        (7, 8, [9, 10])  # 注意：元組本身不可變，但可以包含可變元素
    ]
    
    # 淺拷貝
    shallow = copy.copy(original)
    
    # 深拷貝
    deep = copy.deepcopy(original)
    
    print(f"原始對象: {original}")
    print(f"\n淺拷貝對象: {shallow}")
    print(f"深拷貝對象: {deep}")
    
    # 驗證對象標識
    print(f"\n=== 對象標識驗證 ===")
    print(f"original is shallow: {original is shallow}")
    print(f"original is deep: {original is deep}")
    print(f"shallow is deep: {shallow is deep}")
    
    print(f"\n=== 內層對象標識 ===")
    print(f"original[1] is shallow[1]: {original[1] is shallow[1]}")
    print(f"original[1] is deep[1]: {original[1] is deep[1]}")
    print(f"original[2] is shallow[2]: {original[2] is shallow[2]}")
    print(f"original[2] is deep[2]: {original[2] is deep[2]}")
    print(f"original[2]['b'] is shallow[2]['b']: {original[2]['b'] is shallow[2]['b']}")
    print(f"original[2]['b'] is deep[2]['b']: {original[2]['b'] is deep[2]['b']}")
    
    # 修改測試
    print(f"\n=== 修改測試 ===")
    
    # 修改原始對象的嵌套列表
    original[1].append(99)
    print(f"修改 original[1].append(99) 後:")
    print(f"  原始: {original}")
    print(f"  淺拷貝: {shallow}")  # 淺拷貝被影響
    print(f"  深拷貝: {deep}")      # 深拷貝不受影響
    
    # 修改原始對象的嵌套字典中的列表
    original[2]['b'].append(100)
    print(f"\n修改 original[2]['b'].append(100) 後:")
    print(f"  原始: {original}")
    print(f"  淺拷貝: {shallow}")  # 淺拷貝被影響
    print(f"  深拷貝: {deep}")      # 深拷貝不受影響
    
    # 注意：元組中的列表
    print(f"\n=== 注意：元組中的可變元素 ===")
    print(f"original[3] is shallow[3]: {original[3] is shallow[3]}")
    print(f"original[3] is deep[3]: {original[3] is deep[3]}")
    
    # 嘗試修改元組中的列表
    try:
        original[3][2].append(11)
        print(f"\n修改 original[3][2].append(11) 後:")
        print(f"  原始: {original}")
        print(f"  淺拷貝: {shallow}")  # 淺拷貝被影響
        print(f"  深拷貝: {deep}")      # 深拷貝不受影響
    except TypeError as e:
        print(f"錯誤: {e}")
    
    return original, shallow, deep

original, shallow, deep = demonstrate_deep_copy()

import copy

class ComplexObject:
    """一個複雜的自定義類，用於演示深拷貝"""
    
    def __init__(self, value, children=None):
        self.value = value
        self.children = children if children is not None else []
        self.metadata = {'created': 'today', 'version': 1}
    
    def add_child(self, child):
        self.children.append(child)
    
    def __repr__(self):
        return f"ComplexObject(value={self.value}, children={self.children}, metadata={self.metadata})"
    
    def __deepcopy__(self, memo):
        """自定義深拷貝方法"""
        print(f"  深拷貝 ComplexObject: value={self.value}, id={id(self)}")
        
        # 使用memo字典避免循環引用導致的無限遞歸
        if id(self) in memo:
            return memo[id(self)]
        
        # 創建新對象
        cls = self.__class__
        new_obj = cls.__new__(cls)
        
        # 將新對象添加到memo中，在處理循環引用時使用
        memo[id(self)] = new_obj
        
        # 遞歸深拷貝屬性
        new_obj.value = copy.deepcopy(self.value, memo)
        new_obj.children = copy.deepcopy(self.children, memo)
        new_obj.metadata = copy.deepcopy(self.metadata, memo)
        
        return new_obj

def demonstrate_deepcopy_mechanism():
    """演示深拷貝機制"""
    
    print("=== 深拷貝機制演示 ===")
    
    # 創建循環引用
    obj1 = ComplexObject("parent")
    obj2 = ComplexObject("child1")
    obj3 = ComplexObject("child2")
    
    obj1.add_child(obj2)
    obj1.add_child(obj3)
    obj2.add_child(obj1)  # 創建循環引用
    
    print(f"原始對象:")
    print(f"  obj1: {obj1}")
    print(f"  obj1.children[0]: {obj1.children[0]}")
    print(f"  obj1.children[0].children[0] is obj1: {obj1.children[0].children[0] is obj1}")
    
    print(f"\n執行深拷貝:")
    # memo字典用於跟蹤已拷貝的對象，避免無限遞歸
    memo = {}
    obj1_copy = copy.deepcopy(obj1, memo)
    
    print(f"\n深拷貝結果:")
    print(f"  obj1_copy: {obj1_copy}")
    print(f"  obj1_copy is obj1: {obj1_copy is obj1}")
    print(f"  obj1_copy.children[0] is obj1.children[0]: {obj1_copy.children[0] is obj1.children[0]}")
    print(f"  obj1_copy.children[0].children[0] is obj1_copy: {obj1_copy.children[0].children[0] is obj1_copy}")
    print(f"  memo字典大小: {len(memo)}")
    
    # 修改原始對象
    obj1.value = "MODIFIED"
    obj1.metadata['version'] = 2
    obj1.children[0].value = "CHILD_MODIFIED"
    
    print(f"\n修改原始對象後:")
    print(f"  原始obj1: {obj1}")
    print(f"  拷貝obj1_copy: {obj1_copy}")
    
    return obj1, obj1_copy

obj1, obj1_copy = demonstrate_deepcopy_mechanism()

import copy
import time
import sys

def benchmark_copy_performance():
    """對比深淺拷貝性能"""
    
    print("=== 拷貝性能對比 ===")
    
    # 創建大型嵌套數據結構
    def create_nested_structure(depth, width):
        """創建深度為depth，寬度為width的嵌套結構"""
        if depth == 0:
            return list(range(width))
        
        result = []
        for i in range(width):
            result.append(create_nested_structure(depth - 1, width))
        return result
    
    # 測試不同大小的數據結構
    test_cases = [
        ("小結構", create_nested_structure(2, 3)),
        ("中結構", create_nested_structure(3, 4)),
        ("大結構", create_nested_structure(4, 5)),
    ]
    
    for name, data in test_cases:
        print(f"\n測試 {name}:")
        
        # 估算大小
        size = sys.getsizeof(data)
        print(f"  對象大小: {size} 字節")
        
        # 淺拷貝性能
        start = time.perf_counter()
        for _ in range(100 if name == "大結構" else 1000):
            copy.copy(data)
        shallow_time = time.perf_counter() - start
        
        # 深拷貝性能
        start = time.perf_counter()
        for _ in range(100 if name == "大結構" else 1000):
            copy.deepcopy(data)
        deep_time = time.perf_counter() - start
        
        print(f"  淺拷貝時間: {shallow_time:.6f}秒")
        print(f"  深拷貝時間: {deep_time:.6f}秒")
        print(f"  深拷貝/淺拷貝時間比: {deep_time/shallow_time:.2f}")
    
    # 特別測試：包含大量重複引用的結構
    print(f"\n=== 測試包含大量重複引用的結構 ===")
    
    # 創建一個共享的子對象
    shared_list = list(range(100))
    
    # 創建一個包含多個對同一子對象引用的結構
    data_with_references = []
    for i in range(100):
        data_with_references.append({
            'id': i,
            'data': shared_list,  # 所有字典共享同一個列表
            'metadata': {'index': i}
        })
    
    print(f"  創建了100個字典，都引用同一個列表")
    
    # 深淺拷貝對比
    start = time.perf_counter()
    shallow_copies = [copy.copy(d) for d in data_with_references]
    shallow_time = time.perf_counter() - start
    
    start = time.perf_counter()
    deep_copies = [copy.deepcopy(d) for d in data_with_references]
    deep_time = time.perf_counter() - start
    
    print(f"  淺拷貝時間: {shallow_time:.6f}秒")
    print(f"  深拷貝時間: {deep_time:.6f}秒")
    print(f"  深拷貝/淺拷貝時間比: {deep_time/shallow_time:.2f}")
    
    # 驗證淺拷貝中的引用共享
    print(f"\n  驗證引用共享:")
    print(f"    data_with_references[0]['data'] is data_with_references[1]['data']: "
          f"{data_with_references[0]['data'] is data_with_references[1]['data']}")
    print(f"    shallow_copies[0]['data'] is shallow_copies[1]['data']: "
          f"{shallow_copies[0]['data'] is shallow_copies[1]['data']}")
    print(f"    deep_copies[0]['data'] is deep_copies[1]['data']: "
          f"{deep_copies[0]['data'] is deep_copies[1]['data']}")

benchmark_copy_performance()

def when_to_use_shallow_copy():
    """淺拷貝適用場景分析"""
    
    print("=== 適合使用淺拷貝的場景 ===")
    
    # 場景1：對象內部沒有嵌套的可變對象
    print("\n1. 扁平數據結構:")
    flat_list = [1, 2, 3, 4, 5]
    flat_dict = {'a': 1, 'b': 2, 'c': 3}
    
    list_copy = flat_list.copy()
    dict_copy = flat_dict.copy()
    
    # 修改拷貝不會影響原始對象
    list_copy[0] = 100
    dict_copy['a'] = 100
    
    print(f"   原始列表: {flat_list}")
    print(f"   拷貝列表: {list_copy}")
    print(f"   原始字典: {flat_dict}")
    print(f"   拷貝字典: {dict_copy}")
    
    # 場景2：明確需要共享內部對象
    print("\n2. 需要共享內部對象:")
    
    class DatabaseConnection:
        """模擬數據庫連接"""
        def __init__(self, connection_string):
            self.connection_string = connection_string
            self._connection = None
            self.stats = {'queries': 0, 'errors': 0}
        
        def execute(self, query):
            self.stats['queries'] += 1
            return f"Executed: {query}"
        
        def __repr__(self):
            return f"DatabaseConnection(stats={self.stats})"
    
    # 創建主連接
    main_conn = DatabaseConnection("server=main;database=app")
    
    # 創建多個"副本"，共享相同的統計信息
    connections = []
    for i in range(3):
        conn_copy = copy.copy(main_conn)
        connections.append(conn_copy)
    
    # 所有"副本"執行查詢
    for i, conn in enumerate(connections):
        conn.execute(f"SELECT * FROM table{i}")
    
    print(f"   所有連接共享統計信息:")
    print(f"   主連接: {main_conn}")
    for i, conn in enumerate(connections):
        print(f"   連接{i}: {conn}")
    
    # 場景3：性能敏感，且可以接受共享
    print("\n3. 性能敏感場景:")
    
    # 模擬大型配置對象
    large_config = {
        'app_name': 'MyApp',
        'version': '1.0',
        'features': ['auth', 'logging', 'caching'],  # 這個列表是共享的
        'settings': {
            'timeout': 30,
            'retries': 3
        }
    }
    
    # 快速創建多個配置副本（淺拷貝）
    configs = []
    start = time.perf_counter()
    for i in range(10000):
        configs.append(large_config.copy())  # 淺拷貝，速度快
    shallow_time = time.perf_counter() - start
    
    # 與深拷貝對比
    configs.clear()
    start = time.perf_counter()
    for i in range(10000):
        configs.append(copy.deepcopy(large_config))  # 深拷貝，速度慢
    deep_time = time.perf_counter() - start
    
    print(f"   創建10000個配置副本:")
    print(f"     淺拷貝時間: {shallow_time:.4f}秒")
    print(f"     深拷貝時間: {deep_time:.4f}秒")
    print(f"     性能差異: {deep_time/shallow_time:.1f}倍")
    
    return large_config, configs

large_config, configs = when_to_use_shallow_copy()

def when_to_use_deep_copy():
    """深拷貝適用場景分析"""
    
    print("=== 必須使用深拷貝的場景 ===")
    
    # 場景1：需要完全獨立的數據副本
    print("\n1. 需要完全獨立的數據副本:")
    
    original = {
        'users': [
            {'id': 1, 'name': 'Alice', 'permissions': ['read', 'write']},
            {'id': 2, 'name': 'Bob', 'permissions': ['read']}
        ],
        'settings': {
            'max_users': 100,
            'allowed_ips': ['192.168.1.1', '192.168.1.2']
        }
    }
    
    # 創建完全獨立的副本
    independent_copy = copy.deepcopy(original)
    
    # 修改拷貝中的嵌套數據
    independent_copy['users'][0]['permissions'].append('admin')
    independent_copy['settings']['allowed_ips'].append('10.0.0.1')
    
    print(f"   原始數據:")
    print(f"     users[0]: {original['users'][0]}")
    print(f"     settings: {original['settings']}")
    print(f"\n   深拷貝數據:")
    print(f"     users[0]: {independent_copy['users'][0]}")
    print(f"     settings: {independent_copy['settings']}")
    
    # 場景2：函數需要修改參數但不影響調用者
    print("\n2. 函數內部修改參數:")
    
    def process_data_bad(data):
        """有問題的實現：直接修改輸入數據"""
        # 修改數據
        data['processed'] = True
        data['values'].append('new_value')
        return data
    
    def process_data_good(data):
        """好的實現：創建深拷貝後再修改"""
        # 創建深拷貝
        data_copy = copy.deepcopy(data)
        
        # 修改拷貝
        data_copy['processed'] = True
        data_copy['values'].append('new_value')
        return data_copy
    
    input_data = {
        'id': 1,
        'values': ['a', 'b', 'c']
    }
    
    print(f"   輸入數據: {input_data}")
    
    # 有問題的函數調用
    result_bad = process_data_bad(input_data)
    print(f"\n   調用有問題的函數後:")
    print(f"     返回結果: {result_bad}")
    print(f"     輸入數據被修改: {input_data}")
    
    # 恢復數據
    input_data = {
        'id': 1,
        'values': ['a', 'b', 'c']
    }
    
    # 好的函數調用
    result_good = process_data_good(input_data)
    print(f"\n   調用好的函數後:")
    print(f"     返回結果: {result_good}")
    print(f"     輸入數據未被修改: {input_data}")
    
    # 場景3：緩存或快照需要隔離
    print("\n3. 創建數據快照:")
    
    class DocumentEditor:
        """文檔編輯器，支持撤銷操作"""
        
        def __init__(self):
            self.content = []
            self.history = []  # 保存歷史快照
            self.max_history = 10
        
        def insert_text(self, text, position=None):
            """插入文本並保存歷史"""
            # 保存當前狀態到歷史（深拷貝）
            self.history.append(copy.deepcopy(self.content))
            
            # 限制歷史記錄數量
            if len(self.history) > self.max_history:
                self.history.pop(0)
            
            # 插入文本
            if position is None:
                self.content.append(text)
            else:
                self.content.insert(position, text)
        
        def undo(self):
            """撤銷到上一個狀態"""
            if self.history:
                self.content = self.history.pop()
        
        def __str__(self):
            return f"DocumentEditor(content={self.content}, history_size={len(self.history)})"
    
    editor = DocumentEditor()
    editor.insert_text("Hello")
    editor.insert_text("World")
    editor.insert_text("!")
    
    print(f"   當前編輯器狀態: {editor}")
    
    # 修改當前內容
    editor.content[0] = "Hi"
    print(f"   修改後: {editor}")
    
    # 撤銷
    editor.undo()
    print(f"   撤銷後: {editor}")
    
    return original, independent_copy, editor

original, independent_copy, editor = when_to_use_deep_copy()

def handle_circular_references():
    """處理循環引用"""
    
    print("=== 循環引用的拷貝處理 ===")
    
    # 創建循環引用
    a = []
    b = [a]
    a.append(b)  # a包含b，b包含a
    
    print(f"原始對象:")
    print(f"  a: {a}")
    print(f"  b: {b}")
    print(f"  a[0] is b: {a[0] is b}")
    print(f"  b[0] is a: {b[0] is a}")
    
    # 嘗試深拷貝
    try:
        print(f"\n嘗試深拷貝...")
        a_copy = copy.deepcopy(a)
        print(f"成功深拷貝循環引用結構")
        print(f"  a_copy: {a_copy}")
        print(f"  a_copy[0][0] is a_copy: {a_copy[0][0] is a_copy}")
    except RecursionError as e:
        print(f"錯誤: {e}")
    
    # 更復雜的循環引用
    print(f"\n=== 更復雜的循環引用 ===")
    
    node1 = {'id': 1, 'neighbors': []}
    node2 = {'id': 2, 'neighbors': []}
    node3 = {'id': 3, 'neighbors': []}
    
    # 創建循環引用
    node1['neighbors'].append(node2)
    node2['neighbors'].append(node3)
    node3['neighbors'].append(node1)
    
    print(f"圖結構:")
    print(f"  node1['neighbors'][0] is node2: {node1['neighbors'][0] is node2}")
    print(f"  node2['neighbors'][0] is node3: {node2['neighbors'][0] is node3}")
    print(f"  node3['neighbors'][0] is node1: {node3['neighbors'][0] is node1}")
    
    # 深拷貝
    print(f"\n深拷貝圖結構...")
    node1_copy = copy.deepcopy(node1)
    
    print(f"拷貝結果驗證:")
    print(f"  node1_copy is node1: {node1_copy is node1}")
    print(f"  node1_copy['neighbors'][0] is node2: {node1_copy['neighbors'][0] is node2}")
    print(f"  node1_copy['neighbors'][0] is node1_copy['neighbors'][0]: {node1_copy['neighbors'][0] is node1_copy['neighbors'][0]}")
    print(f"  node1_copy['neighbors'][0]['neighbors'][0]['neighbors'][0] is node1_copy: "
          f"{node1_copy['neighbors'][0]['neighbors'][0]['neighbors'][0] is node1_copy}")
    
    return a, b, node1, node1_copy

a, b, node1, node1_copy = handle_circular_references()

def custom_class_copy_control():
    """自定義類的拷貝控制"""
    
    print("=== 自定義類的拷貝控制 ===")
    
    class TreeNode:
        """樹節點，自定義拷貝行為"""
        
        def __init__(self, value, children=None):
            self.value = value
            self._children = children if children is not None else []
            self.parent = None
            
            # 設置父節點引用
            for child in self._children:
                child.parent = self
        
        @property
        def children(self):
            return self._children
        
        def add_child(self, child):
            self._children.append(child)
            child.parent = self
        
        def __copy__(self):
            """自定義淺拷貝"""
            print(f"  執行TreeNode淺拷貝: value={self.value}")
            
            # 創建新節點，但不拷貝子節點
            new_node = TreeNode(self.value)
            
            # 注意：新節點的children列表是空的
            # parent引用也不會設置
            
            return new_node
        
        def __deepcopy__(self, memo=None):
            """自定義深拷貝"""
            print(f"  執行TreeNode深拷貝: value={self.value}")
            
            if memo is None:
                memo = {}
            
            # 避免循環引用
            if id(self) in memo:
                return memo[id(self)]
            
            # 創建新節點
            new_node = TreeNode(self.value)
            memo[id(self)] = new_node
            
            # 遞歸深拷貝子節點
            for child in self._children:
                new_child = copy.deepcopy(child, memo)
                new_node.add_child(new_child)
            
            return new_node
        
        def __repr__(self):
            children_values = [c.value for c in self._children]
            parent_value = self.parent.value if self.parent else None
            return f"TreeNode(value={self.value}, children={children_values}, parent={parent_value})"
    
    # 創建樹結構
    root = TreeNode("root")
    child1 = TreeNode("child1")
    child2 = TreeNode("child2")
    grandchild1 = TreeNode("grandchild1")
    
    root.add_child(child1)
    root.add_child(child2)
    child1.add_child(grandchild1)
    
    print(f"原始樹:")
    print(f"  root: {root}")
    print(f"  child1: {child1}")
    print(f"  grandchild1: {grandchild1}")
    
    # 淺拷貝
    print(f"\n淺拷貝root:")
    root_shallow = copy.copy(root)
    print(f"  root_shallow: {root_shallow}")
    
    # 深拷貝
    print(f"\n深拷貝root:")
    root_deep = copy.deepcopy(root)
    print(f"  root_deep: {root_deep}")
    
    # 驗證
    print(f"\n驗證拷貝結果:")
    print(f"  root is root_shallow: {root is root_shallow}")
    print(f"  root is root_deep: {root is root_deep}")
    print(f"  root.children[0] is root_deep.children[0]: {root.children[0] is root_deep.children[0]}")
    
    # 修改原始樹
    root.value = "ROOT_MODIFIED"
    child1.value = "CHILD1_MODIFIED"
    
    print(f"\n修改原始樹後:")
    print(f"  原始root: {root}")
    print(f"  深拷貝root_deep: {root_deep}")
    
    return root, root_shallow, root_deep

root, root_shallow, root_deep = custom_class_copy_control()

def copy_decision_guide():
    """拷貝決策指南"""
    
    print("=== Python拷貝決策指南 ===")
    
    guide = """
    拷貝決策流程：
    
    1. 是否需要創建新對象？
       │
       ├─ 否 → 使用引用（直接賦值）
       │
       └─ 是 → 繼續第2步
    
    2. 數據結構是否扁平（沒有嵌套的可變對象）？
       │
       ├─ 是 → 使用淺拷貝（.copy()、切片、copy.copy()）
       │
       └─ 否 → 繼續第3步
    
    3. 是否需要完全獨立的副本？
       │
       ├─ 否 → 使用淺拷貝
       │      （當可以接受共享內部對象時）
       │
       └─ 是 → 繼續第4步
    
    4. 是否有循環引用？
       │
       ├─ 否 → 使用深拷貝（copy.deepcopy()）
       │
       └─ 是 → 使用深拷貝，但注意：
                - copy.deepcopy()可以處理大多數循環引用
                - 對於特別複雜的結構，可能需要自定義__deepcopy__()
    
    5. 性能是否關鍵？
       │
       ├─ 是 → 考慮：
               - 使用淺拷貝
               - 部分深拷貝（只拷貝需要的部分）
               - 不可變數據結構
       │
       └─ 否 → 使用深拷貝確保安全
    """
    
    print(guide)
    
    # 常見場景建議
    print("\n=== 常見場景建議 ===")
    
    scenarios = [
        {
            "場景": "配置對象模板",
            "建議": "深拷貝",
            "理由": "每個實例需要獨立的配置，避免意外共享"
        },
        {
            "場景": "函數參數保護",
            "建議": "深拷貝或不可變結構",
            "理由": "確保函數不意外修改調用者的數據"
        },
        {
            "場景": "緩存或快照",
            "建議": "深拷貝",
            "理由": "需要完全隔離的歷史狀態"
        },
        {
            "場景": "性能關鍵循環",
            "建議": "淺拷貝或視圖",
            "理由": "減少內存分配和拷貝開銷"
        },
        {
            "場景": "只讀數據共享",
            "建議": "引用或淺拷貝",
            "理由": "多個使用者可以安全共享不可變數據"
        },
        {
            "場景": "數據序列化/反序列化",
            "建議": "相當於深拷貝",
            "理由": "json.loads(json.dumps(data))創建完全獨立副本"
        }
    ]
    
    for scenario in scenarios:
        print(f"  {scenario['場景']}:")
        print(f"    建議: {scenario['建議']}")
        print(f"    理由: {scenario['理由']}")
        print()
    
    return guide

copy_decision_guide()