# 示例1：int類型（不可變）
a = 10
print(f"修改前a的值：{a}，地址：{id(a)}")  # 輸出：修改前a的值：10，地址：140708484554720

a = a + 2  # 看似“修改”，實際創(chuàng)建新對象
print(f"修改后a的值：{a}，地址：{id(a)}")  # 輸出：修改后a的值：12，地址：140708484554784（地址變化）

# 示例2：str類型（不可變）
s = "Python"
print(f"修改前s的值：{s}，地址：{id(s)}")  # 輸出：修改前s的值：Python，地址：2524607223408

s = s.replace("P", "p")  # replace()返回新字符串，原對象不變
print(f"修改后s的值：{s}，地址：{id(s)}")  # 輸出：修改后s的值：python，地址：2524607223664（地址變化）

# 示例3：tuple類型（不可變）
t = (1, 2, 3)
# t[0] = 100  # 報錯：TypeError: 'tuple' object does not support item assignment（無法修改元素）

# 示例1：list類型（可變）
lst = [1, 2, 3]
print(f"修改前l(fā)st的值：{lst}，地址：{id(lst)}")  # 輸出：修改前l(fā)st的值：[1,2,3]，地址：2524607215232

lst.append(4)  # 直接修改列表內部數(shù)據(jù)
print(f"修改后lst的值：{lst}，地址：{id(lst)}")  # 輸出：修改后lst的值：[1,2,3,4]，地址：2524607215232（地址不變）

# 示例2：dict類型（可變）
d = {"name": "張三", "age": 25}
print(f"修改前d的值：wppm3vysvbp，地址：{id(d)}")  # 輸出：修改前d的值：{'name':'張三','age':25}，地址：2524607214848

d["age"] = 26  # 直接修改字典value
print(f"修改后d的值：wppm3vysvbp，地址：{id(d)}")  # 輸出：修改后d的值：{'name':'張三','age':26}，地址：2524607214848（地址不變）

# 示例3：set類型（可變）
s = {1, 2, 3}
print(f"修改前s的值：{s}，地址：{id(s)}")  # 輸出：修改前s的值：{1,2,3}，地址：2524607198976

s.add(4)  # 直接修改集合內部數(shù)據(jù)
print(f"修改后s的值：{s}，地址：{id(s)}")  # 輸出：修改后s的值：{1,2,3,4}，地址：2524607198976（地址不變）

# 初始賦值：a指向id=140708484554720的對象（value=10）
a = 10
內存：a → [id=140708484554720, value=10, type=int]

# “修改”操作：創(chuàng)建新對象（id=140708484554784，value=12），a重新指向新對象
a = a + 2
內存：a → [id=140708484554784, value=12, type=int]（原對象10仍存在，等待垃圾回收）

# 初始賦值：lst指向id=2524607215232的列表對象（內部存儲[1,2,3]）
lst = [1, 2, 3]
內存：lst → [id=2524607215232, value=[1,2,3], type=list]

# 直接修改：列表內部數(shù)據(jù)變?yōu)閇1,2,3,4]，但lst仍指向原id
lst.append(4)
內存：lst → [id=2524607215232, value=[1,2,3,4], type=list]（id不變，僅value修改）

# 示例1：小整數(shù)緩存（范圍通常是-5~256）
a = 10
b = 10
print(id(a) == id(b))  # 輸出：True（復用同一對象）

c = 1000
d = 1000
print(id(c) == id(d))  # 輸出：False（超出小整數(shù)范圍，創(chuàng)建新對象）

# 示例2：短字符串緩存（字符串駐留機制）
s1 = "Python"
s2 = "Python"
print(id(s1) == id(s2))  # 輸出：True（復用同一對象）

s3 = "Python123"
s4 = "Python123"
print(id(s3) == id(s4))  # 輸出：True（短字符串通常會被緩存）

s5 = "Python " + "123"  # 動態(tài)拼接的字符串，是否緩存取決于解釋器
print(id(s5) == id(s3))  # 輸出：False（動態(tài)拼接未觸發(fā)緩存）

a = 10
b = a  # b指向a的對象（id相同）
print(f"a: {a}, id(a): {id(a)}; b: , id(b): {id(b)}")  # 輸出：a:10, id(a):140708484554720; b:10, id(b):140708484554720

a = a + 2  # a指向新對象（id變化）
print(f"a: {a}, id(a): {id(a)}; b: , id(b): {id(b)}")  # 輸出：a:12, id(a):140708484554784; b:10, id(b):140708484554720（b不受影響）

lst1 = [1, 2, 3]
lst2 = lst1  # lst2與lst1指向同一對象（共享引用）
print(f"lst1: {lst1}, id(lst1): {id(lst1)}; lst2: {lst2}, id(lst2): {id(lst2)}")  # 輸出：lst1:[1,2,3], id(lst1):2524607215232; lst2:[1,2,3], id(lst2):2524607215232

lst1.append(4)  # 修改lst1（共享對象）
print(f"lst1: {lst1}, id(lst1): {id(lst1)}; lst2: {lst2}, id(lst2): {id(lst2)}")  # 輸出：lst1:[1,2,3,4], id(lst1):2524607215232; lst2:[1,2,3,4], id(lst2):2524607215232（lst2同步變化）

def modify_immutable(x):
    x = x + 10  # 創(chuàng)建新對象，參數(shù)x指向新id
    print(f"函數(shù)內x: {x}, id(x): {id(x)}")

a = 5
print(f"調用前a: {a}, id(a): {id(a)}")  # 輸出：調用前a:5, id(a):140708484554560
modify_immutable(a)  # 輸出：函數(shù)內x:15, id(x):140708484554880
print(f"調用后a: {a}, id(a): {id(a)}")  # 輸出：調用后a:5, id(a):140708484554560（a不受影響）

def modify_mutable(lst):
    lst.append(10)  # 直接修改共享對象
    print(f"函數(shù)內lst: {lst}, id(lst): {id(lst)}")

lst = [1, 2, 3]
print(f"調用前l(fā)st: {lst}, id(lst): {id(lst)}")  # 輸出：調用前l(fā)st:[1,2,3], id(lst):2524607215232
modify_mutable(lst)  # 輸出：函數(shù)內lst:[1,2,3,10], id(lst):2524607215232
print(f"調用后lst: {lst}, id(lst): {id(lst)}")  # 輸出：調用后lst:[1,2,3,10], id(lst):2524607215232（lst被修改）

def modify_mutable_safe(lst):
    new_lst = lst.copy()  # 創(chuàng)建副本，修改副本不影響原對象
    new_lst.append(10)
    print(f"函數(shù)內new_lst: {new_lst}")

lst = [1, 2, 3]
modify_mutable_safe(lst)  # 輸出：函數(shù)內new_lst: [1,2,3,10]
print(f"調用后lst: {lst}")  # 輸出：調用后lst: [1,2,3]（原對象未修改）

# 示例：不可變對象作為字典鍵（合法）
config = {
    ("db", "host"): "localhost",  # 元組（不可變）作為鍵
    ("db", "port"): 3306,
    "timeout": 30  # 字符串（不可變）作為鍵
}

# 錯誤示例：列表（可變）不能作為字典鍵
invalid_config = {
    ["db", "host"]: "localhost"  # 報錯：TypeError: unhashable type: 'list'
}

# 示例：可變對象存儲動態(tài)數(shù)據(jù)
user_scores = {"張三": 85, "李四": 92}
# 動態(tài)更新分數(shù)（無需創(chuàng)建新字典，直接修改）
user_scores["張三"] = 88  # 覆蓋原分數(shù)
user_scores["王五"] = 79  # 新增數(shù)據(jù)
print(user_scores)  # 輸出：{'張三': 88, '李四': 92, '王五': 79}

# 示例：函數(shù)間傳遞可變對象并協(xié)作修改
def add_task(tasks, task):
    tasks.append(task)  # 直接修改傳入的列表

task_list = ["寫代碼", "測功能"]
add_task(task_list, "修復BUG")
print(task_list)  # 輸出：['寫代碼', '測功能', '修復BUG']（原列表被更新）

# 錯誤示例：用列表作為默認參數(shù)
def add_item(item, lst=[]):  # lst在函數(shù)定義時初始化一次
    lst.append(item)
    return lst

print(add_item(1))  # 輸出：[1]（首次調用正常）
print(add_item(2))  # 輸出：[1, 2]（二次調用復用了同一個列表，意外累積）

def add_item(item, lst=None):
    if lst is None:
        lst = []  # 每次調用時重新初始化列表
    lst.append(item)
    return lst

print(add_item(1))  # 輸出：[1]
print(add_item(2))  # 輸出：[2]（符合預期）

# 問題場景：復制列表時直接賦值（共享引用）
user_list = ["張三", "李四", "王五"]
admin_list = user_list  # admin_list與user_list指向同一列表

admin_list.remove("王五")  # 修改admin_list
print(user_list)  # 輸出：['張三', '李四']（user_list也被修改，可能非預期）

# 方案1：淺拷貝（適用于元素為不可變對象的情況）
user_list = ["張三", "李四", "王五"]
admin_list = user_list.copy()  # 列表專用拷貝
# 或 admin_list = list(user_list)
# 或 admin_list = user_list[:]

admin_list.remove("王五")
print(user_list)  # 輸出：['張三', '李四', '王五']（原列表不受影響）

# 方案2：深拷貝（適用于嵌套可變對象的情況，需用copy模塊）
import copy
nested_list = [1, [2, 3], 4]
shallow_copy = nested_list.copy()  # 淺拷貝：內層列表仍共享
deep_copy = copy.deepcopy(nested_list)  # 深拷貝：完全獨立

shallow_copy[1].append(5)
print(nested_list)  # 輸出：[1, [2, 3, 5], 4]（淺拷貝影響原對象）
deep_copy[1].append(6)
print(nested_list)  # 輸出：[1, [2, 3, 5], 4]（深拷貝不影響原對象）

# 錯誤示例：直接修改字符串
s = "Python"
s[0] = "p"  # 報錯：TypeError: 'str' object does not support item assignment

# 錯誤示例：直接修改元組
t = (1, 2, 3)
t[0] = 100  # 報錯：TypeError: 'tuple' object does not support item assignment

# 正確：字符串重新賦值
s = "Python"
s = "p" + s[1:]  # 生成新字符串
print(s)  # 輸出：python

# 正確：元組重新賦值（通過切片生成新元組）
t = (1, 2, 3)
t = (100,) + t[1:]  # 生成新元組
print(t)  # 輸出：(100, 2, 3)