my_list = [1, 2, 3, "a", "b"]
my_tuple = tuple(my_list)  # 關(guān)鍵：使用tuple()構(gòu)造函數(shù)

print("Original list:", my_list)      # [1, 2, 3, 'a', 'b']
print("Converted tuple:", my_tuple)   # (1, 2, 3, 'a', 'b')
print("Type check:", type(my_tuple))  # <class 'tuple'>

nested_list = [1, [2, 3], (4, 5)]
nested_tuple = tuple(nested_list)
print(nested_tuple)  # (1, [2, 3], (4, 5)) → 子列表仍是list！

empty_tuple = tuple([])  # 返回空元組 ()

import requests

response = requests.get("https://api.example.com/users")
user_ids = response.json()["ids"]  # 假設(shè)返回 [101, 102, 103]

# 轉(zhuǎn)為tuple作為緩存鍵（list不能作為字典鍵?。?
cache_key = tuple(user_ids)
cache = {cache_key: "user_data"}  # 安全操作 ?

colors = ["red", "blue", "green", "blue", "yellow", "red"]
unique_colors = set(colors)

print("Original list:", colors)       # ['red', 'blue', 'green', 'blue', 'yellow', 'red']
print("Unique set:", unique_colors)   # {'red', 'blue', 'green', 'yellow'} → 重復(fù)項(xiàng)消失！
print("Type check:", type(unique_colors))  # <class 'set'>

import timeit

# 生成含重復(fù)項(xiàng)的列表
test_list = list(range(5000)) * 2  # 10,000元素，50%重復(fù)

# 方法1：用set去重
set_time = timeit.timeit('set(test_list)', globals=globals(), number=1000)

# 方法2：手動(dòng)循環(huán)去重
def manual_unique(lst):
    seen = []
    for item in lst:
        if item not in seen:
            seen.append(item)
    return seen

manual_time = timeit.timeit('manual_unique(test_list)', globals=globals(), number=1000)

print(f"Set去重耗時(shí): {set_time:.4f}秒")
print(f"手動(dòng)去重耗時(shí): {manual_time:.4f}秒")
# 典型輸出：Set去重耗時(shí): 0.0215秒 vs 手動(dòng)去重耗時(shí): 4.8123秒 → 快200倍！

invalid_list = [1, {"key": "value"}, [2, 3]]
# set(invalid_list) → 報(bào)錯(cuò)：TypeError: unhashable type: 'dict'

dict_list = [{"id": 1}, {"id": 2}]
hashable_set = set(tuple(d.items()) for d in dict_list)  # 轉(zhuǎn)為元組集合

nested_list = [[1,2], [3,4]]
tuple_set = set(tuple(sub) for sub in nested_list)

coordinates = (10.5, 20.3, 30.1)
coord_list = list(coordinates)  # 使用list()構(gòu)造函數(shù)

print("Original tuple:", coordinates)  # (10.5, 20.3, 30.1)
print("Converted list:", coord_list)   # [10.5, 20.3, 30.1]

# 現(xiàn)在可以安全修改！
coord_list.append(40.7)
print("Modified list:", coord_list)    # [10.5, 20.3, 30.1, 40.7]

nested_tuple = (1, [2, 3], {"a": 4})
nested_list = list(nested_tuple)

nested_list[1].append(99)  # 修改子列表
print(nested_tuple[1])     # [2, 3, 99] → 原tuple的子列表也被修改！

import copy
safe_list = copy.deepcopy(nested_tuple)
safe_list[1].append(100)
print(nested_tuple[1])  # [2, 3, 99] → 原數(shù)據(jù)不受影響

# 模擬數(shù)據(jù)庫(kù)查詢結(jié)果（每行是tuple）
db_results = [(1, "Alice"), (2, "Bob"), (3, "Charlie")]

# 轉(zhuǎn)為list以便添加新字段
user_list = [list(row) for row in db_results]
for user in user_list:
    user.append("active")  # 添加狀態(tài)字段

print(user_list)  # [[1, 'Alice', 'active'], ...]

status_codes = (200, 404, 200, 500, 403)
unique_codes = set(status_codes)

print("Original tuple:", status_codes)  # (200, 404, 200, 500, 403)
print("Unique set:", unique_codes)     # {200, 404, 500, 403}
print("404 in set?", 404 in unique_codes)  # True → 成員檢查O(1)時(shí)間！

big_tuple = tuple(range(1000000))
big_set = set(big_tuple)

%timeit 999999 in big_tuple  # ~10ms (線性搜索)
%timeit 999999 in big_set    # ~0.01ms (哈希查找)

response_times = (0.2, 0.5, 0.2, 1.0, 0.3)  # 模擬響應(yīng)時(shí)間元組
unique_times = set(response_times)

print(f"總請(qǐng)求數(shù): {len(response_times)}")
print(f"唯一響應(yīng)時(shí)間: {len(unique_times)}")
print(f"最快響應(yīng): {min(unique_times)}s")  # 0.2

unique_numbers = {5, 1, 3, 2, 4}
number_list = list(unique_numbers)

print("Original set:", unique_numbers)  # {1, 2, 3, 4, 5} (順序可能不同)
print("Converted list:", number_list)   # [1, 2, 3, 4, 5] → 順序不保證一致！

# 按數(shù)字升序
sorted_list = sorted(unique_numbers)  # [1, 2, 3, 4, 5]

# 按字符串長(zhǎng)度降序（自定義key）
words = {"apple", "banana", "cherry"}
sorted_words = sorted(words, key=len, reverse=True)  # ['banana', 'cherry', 'apple']

s = {1, 2, 3}
l = list(s)
l.append(4)
print(s)  # {1, 2, 3} → 原set不變

user_tags = {"python", "data", "ml", "ai", "web"}
# 轉(zhuǎn)為排序列表生成報(bào)告
report_tags = sorted(user_tags, key=str.lower)  # 按字母排序
print("Top tags:", ", ".join(report_tags))  # "ai, data, ml, python, web"

unique_emails = {"a@example.com", "b@example.com", "a@example.com"}
email_tuple = tuple(unique_emails)

print("Original set:", unique_emails)  # {'a@example.com', 'b@example.com'}
print("Tuple result:", email_tuple)   # ('a@example.com', 'b@example.com') → 順序不定
print("Type check:", type(email_tuple))  # <class 'tuple'>

sorted_tuple = tuple(sorted(unique_emails))
print(sorted_tuple)  # ('a@example.com', 'b@example.com') → 確定順序

def get_data(params: set):
    # 將參數(shù)集轉(zhuǎn)為有序元組作為緩存鍵
    cache_key = tuple(sorted(params))
    # ... 用cache_key查詢緩存
    return cache_key

print(get_data({"user_id", "token"}))  # ('token', 'user_id') → 順序一致

# 問(wèn)題：混合嵌套結(jié)構(gòu)
mixed_data = [1, (2, [3, 4]), {"a": [5, 6]}]

# 錯(cuò)誤：直接轉(zhuǎn)set會(huì)失?。ú豢晒＃?
# set(mixed_data) → TypeError

# 正確方案：遞歸轉(zhuǎn)換函數(shù)
def deep_convert_to_set(obj):
    if isinstance(obj, (list, tuple)):
        return frozenset(deep_convert_to_set(item) for item in obj)
    elif isinstance(obj, dict):
        return frozenset((k, deep_convert_to_set(v)) for k, v in obj.items())
    return obj

result = deep_convert_to_set(mixed_data)
print(result)  # frozenset({1, frozenset({2, frozenset({3, 4})}), ...})

# 反模式：每次循環(huán)都轉(zhuǎn)set
for item in huge_list:
    if item in set(huge_list):  # 每次新建set！
        ...

# 正確：提前轉(zhuǎn)換
unique_set = set(huge_list)
for item in huge_list:
    if item in unique_set:  # O(1)檢查

# 更快的有序去重（保留首次出現(xiàn)順序）
ordered_unique = list(dict.fromkeys(huge_list))

def safe_tuple_to_list(tup):
    try:
        return list(tup)
    except TypeError as e:
        print(f"轉(zhuǎn)換失敗: {e}")
        # 嘗試修復(fù)：遞歸轉(zhuǎn)換子元素
        return [safe_tuple_to_list(item) if isinstance(item, tuple) else item 
                for item in tup]

# 測(cè)試含不可哈希對(duì)象的元組
problematic = (1, {"key": "value"})
print(safe_tuple_to_list(problematic))  # [1, {'key': 'value'}]

# 1. 從文件讀取日志（每行是tuple）
with open("logs.txt") as f:
    log_tuples = [tuple(line.strip().split()) for line in f]

# 2. 提取唯一IP地址（tuple → set）
unique_ips = {ip for _, ip, _ in log_tuples}

# 3. 轉(zhuǎn)為排序列表生成報(bào)告（set → list）
report_ips = sorted(unique_ips, key=lambda ip: [int(x) for x in ip.split('.')])

# 4. 創(chuàng)建不可變配置（list → tuple）
config = tuple(report_ips[:5])  # 前5個(gè)高頻IP

print("Top IPs:", config)