Python中list、tuple和set三大容器的相互转换技巧

my_list = [1, 2, 3, "a", "b"]
my_tuple = tuple(my_list)  # 关键：使用tuple()构造函数

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"]  # 假设返回 [101, 102, 103]

# 转为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'} → 重复项消失！
print("Type check:", type(unique_colors))  # <class 'set'>

import timeit

# 生成含重复项的列表
test_list = list(range(5000)) * 2  # 10,000元素，50%重复

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

# 方法2：手动循环去重
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去重耗时: {set_time:.4f}秒")
print(f"手动去重耗时: {manual_time:.4f}秒")
# 典型输出：Set去重耗时: 0.0215秒 vs 手动去重耗时: 4.8123秒 → 快200倍！

invalid_list = [1, {"key": "value"}, [2, 3]]
# set(invalid_list) → 报错：TypeError: unhashable type: 'dict'

dict_list = [{"id": 1}, {"id": 2}]
hashable_set = set(tuple(d.items()) for d in dict_list)  # 转为元组集合

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()构造函数

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

# 现在可以安全修改！
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] → 原数据不受影响

# 模拟数据库查询结果（每行是tuple）
db_results = [(1, "Alice"), (2, "Bob"), (3, "Charlie")]

# 转为list以便添加新字段
user_list = [list(row) for row in db_results]
for user in user_list:
    user.append("active")  # 添加状态字段

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)时间！

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)  # 模拟响应时间元组
unique_times = set(response_times)

print(f"总请求数: {len(response_times)}")
print(f"唯一响应时间: {len(unique_times)}")
print(f"最快响应: {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] → 顺序不保证一致！

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

# 按字符串长度降序（自定义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"}
# 转为排序列表生成报告
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):
    # 将参数集转为有序元组作为缓存键
    cache_key = tuple(sorted(params))
    # ... 用cache_key查询缓存
    return cache_key

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

# 问题：混合嵌套结构
mixed_data = [1, (2, [3, 4]), {"a": [5, 6]}]

# 错误：直接转set会失败（不可哈希）
# set(mixed_data) → TypeError

# 正确方案：递归转换函数
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})}), ...})

# 反模式：每次循环都转set
for item in huge_list:
    if item in set(huge_list):  # 每次新建set！
        ...

# 正确：提前转换
unique_set = set(huge_list)
for item in huge_list:
    if item in unique_set:  # O(1)检查

# 更快的有序去重（保留首次出现顺序）
ordered_unique = list(dict.fromkeys(huge_list))

def safe_tuple_to_list(tup):
    try:
        return list(tup)
    except TypeError as e:
        print(f"转换失败: {e}")
        # 尝试修复：递归转换子元素
        return [safe_tuple_to_list(item) if isinstance(item, tuple) else item 
                for item in tup]

# 测试含不可哈希对象的元组
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. 转为排序列表生成报告（set → list）
report_ips = sorted(unique_ips, key=lambda ip: [int(x) for x in ip.split('.')])

# 4. 创建不可变配置（list → tuple）
config = tuple(report_ips[:5])  # 前5个高频IP

print("Top IPs:", config)