# 定義一個元組
user_data = ("Alice", 30, "Developer")

# 轉(zhuǎn)換為列表
user_list = list(user_data)

print("元組:", user_data)  # 輸出: ('Alice', 30, 'Developer')
print("列表:", user_list)  # 輸出: ['Alice', 30, 'Developer']

# 現(xiàn)在可以修改列表
user_list[1] = 31  # 更新年齡
print("修改后的列表:", user_list)  # 輸出: ['Alice', 31, 'Developer']

# 原始元組保持不變（不可變性）
print("原始元組未變:", user_data)  # 輸出: ('Alice', 30, 'Developer')

# 嵌套元組示例
coordinates = ((1, 2), (3, 4), (5, 6))

# 轉(zhuǎn)換為列表
coord_list = list(coordinates)

print("原始元組:", coordinates)  # 輸出: ((1, 2), (3, 4), (5, 6))
print("轉(zhuǎn)換后的列表:", coord_list)  # 輸出: [(1, 2), (3, 4), (5, 6)]

# 嘗試修改內(nèi)部元素
try:
    coord_list[0][0] = 10  # 試圖修改第一個元組的第一個元素
except TypeError as e:
    print("錯誤:", e)  # 輸出: 'tuple' object does not support item assignment

# 遞歸轉(zhuǎn)換嵌套元組為列表
def tuple_to_list_deep(t):
    if isinstance(t, tuple):
        return [tuple_to_list_deep(item) for item in t]
    return t

deep_list = tuple_to_list_deep(coordinates)
print("深度轉(zhuǎn)換列表:", deep_list)  # 輸出: [[1, 2], [3, 4], [5, 6]]

# 現(xiàn)在可以自由修改
deep_list[0][0] = 10
print("修改后:", deep_list)  # 輸出: [[10, 2], [3, 4], [5, 6]]

import timeit

# 測試大規(guī)模元組轉(zhuǎn)列表
tuple_size = 1_000_000
test_tuple = tuple(range(tuple_size))

# 測量轉(zhuǎn)換時間
conversion_time = timeit.timeit(
    'list(test_tuple)', 
    globals={'test_tuple': test_tuple},
    number=10
)

print(f"轉(zhuǎn)換 {tuple_size} 個元素的元組到列表（10次平均）: {conversion_time:.6f} 秒")
# 典型輸出: 轉(zhuǎn)換 1000000 個元素的元組到列表（10次平均）: 0.152345 秒

import sqlite3

# 模擬數(shù)據(jù)庫查詢
conn = sqlite3.connect(":memory:")
conn.execute("CREATE TABLE users (id INTEGER, name TEXT)")
conn.execute("INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob')")
cursor = conn.execute("SELECT * FROM users")

# 獲取元組結(jié)果
user_tuples = cursor.fetchall()
print("數(shù)據(jù)庫元組:", user_tuples)  # 輸出: [(1, 'Alice'), (2, 'Bob')]

# 轉(zhuǎn)換為列表以修改數(shù)據(jù)
user_list = [list(row) for row in user_tuples]  # 列表推導(dǎo)式批量轉(zhuǎn)換

# 更新所有用戶姓名（示例操作）
for user in user_list:
    user[1] = "Updated: " + user[1]

print("修改后的列表:", user_list)  # 輸出: [[1, 'Updated: Alice'], [2, 'Updated: Bob']]

# 轉(zhuǎn)回元組準(zhǔn)備寫回數(shù)據(jù)庫（假設(shè)需要）
updated_tuples = [tuple(user) for user in user_list]
print("轉(zhuǎn)回元組:", updated_tuples)  # 輸出: [(1, 'Updated: Alice'), (2, 'Updated: Bob')]

# 定義一個列表
shopping_list = ["Apple", "Banana", "Milk"]

# 轉(zhuǎn)換為元組
shopping_tuple = tuple(shopping_list)

print("列表:", shopping_list)  # 輸出: ['Apple', 'Banana', 'Milk']
print("元組:", shopping_tuple)  # 輸出: ('Apple', 'Banana', 'Milk')

# 嘗試修改元組（會失?。?
try:
    shopping_tuple[0] = "Orange"
except TypeError as e:
    print("錯誤:", e)  # 輸出: 'tuple' object does not support item assignment

# 原始列表仍可修改
shopping_list.append("Eggs")
print("列表新增后:", shopping_list)  # 輸出: ['Apple', 'Banana', 'Milk', 'Eggs']

# 元組作為字典鍵
location = (40.7128, -74.0060)  # 紐約坐標(biāo)
city_data = {location: "New York"}
print(city_data[location])  # 輸出: New York

# 列表不能作為字典鍵
try:
    bad_key = {[1,2]: "invalid"}
except TypeError as e:
    print("列表作為鍵錯誤:", e)  # 輸出: unhashable type: 'list'

# 嵌套列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 轉(zhuǎn)換為元組
matrix_tuple = tuple(matrix)

print("原始列表:", matrix)  # 輸出: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("轉(zhuǎn)換后的元組:", matrix_tuple)  # 輸出: ([1, 2, 3], [4, 5, 6], [7, 8, 9])

# 內(nèi)部列表仍可修改！
matrix_tuple[0][0] = 99
print("修改后元組:", matrix_tuple)  # 輸出: ([99, 2, 3], [4, 5, 6], [7, 8, 9])
print("原始列表同步變化:", matrix)  # 輸出: [[99, 2, 3], [4, 5, 6], [7, 8, 9]]

# 深度轉(zhuǎn)換列表為元組
def list_to_tuple_deep(lst):
    if isinstance(lst, list):
        return tuple(list_to_tuple_deep(item) for item in lst)
    return lst

deep_tuple = list_to_tuple_deep(matrix)
print("深度轉(zhuǎn)換元組:", deep_tuple)  # 輸出: ((1, 2, 3), (4, 5, 6), (7, 8, 9))

# 嘗試修改（徹底失?。?
try:
    deep_tuple[0][0] = 100
except TypeError as e:
    print("深度元組修改錯誤:", e)  # 輸出: 'tuple' object does not support item assignment

import timeit

list_size = 1_000_000
test_list = list(range(list_size))

# 測量轉(zhuǎn)換時間
to_tuple_time = timeit.timeit(
    'tuple(test_list)', 
    globals={'test_list': test_list},
    number=10
)

print(f"轉(zhuǎn)換 {list_size} 個元素的列表到元組（10次平均）: {to_tuple_time:.6f} 秒")
# 典型輸出: 轉(zhuǎn)換 1000000 個元素的列表到元組（10次平均）: 0.148721 秒

import sys
data = list(range(1000))
print("列表內(nèi)存:", sys.getsizeof(data))  # 約 9032 字節(jié)
data_tuple = tuple(data)
print("元組內(nèi)存:", sys.getsizeof(data_tuple))  # 約 8056 字節(jié)（節(jié)省約10%）

def process_data(raw_data):
    # 使用列表進行動態(tài)處理
    temp_list = []
    for item in raw_data:
        if item > 0:
            temp_list.append(item * 2)
    
    # 處理完成后轉(zhuǎn)為不可變元組確保安全
    return tuple(temp_list)

# 示例調(diào)用
result = process_data([1, -2, 3, -4, 5])
print("處理結(jié)果:", result)  # 輸出: (2, 6, 10)

# 嘗試修改返回值（失?。?
try:
    result[0] = 100
except TypeError:
    print("返回值受保護，無法修改！?")

# 錯誤：不必要地轉(zhuǎn)換整個列表
data = [1, 2, 3]
temp_tuple = tuple(data)  # 多余步驟
result = sum(temp_tuple)

# 正確：列表直接支持迭代操作
result = sum(data)  # 更簡潔高效

# 大型數(shù)據(jù)集（1億元素）
huge_list = range(100_000_000)

# 錯誤：全量轉(zhuǎn)元組可能內(nèi)存溢出
try:
    huge_tuple = tuple(huge_list)  # 可能崩潰！
except MemoryError:
    print("內(nèi)存不足！?")

# 正確：用生成器逐元素處理
processed = (x * 2 for x in huge_list)  # 生成器表達式
first_five = [next(processed) for _ in range(5)]
print("生成器結(jié)果:", first_five)  # 輸出: [0, 2, 4, 6, 8]

# 元組解包轉(zhuǎn)列表
user = ("Alice", 30, "Developer")
name, age, job = user  # 解包
user_list = [name, age, job]  # 轉(zhuǎn)列表

# 列表解包轉(zhuǎn)元組
colors = ["red", "green", "blue"]
r, g, b = colors
color_tuple = (r, g, b)

# 高級：帶*的解包
numbers = [1, 2, 3, 4, 5]
first, *middle, last = numbers
new_tuple = (first, sum(middle), last)
print(new_tuple)  # 輸出: (1, 9, 5)

class DataContainer:
    def __init__(self, items):
        self.items = items
    
    def __iter__(self):
        return iter(self.items)  # 支持迭代

# 實例化
container = DataContainer([10, 20, 30])

# 直接轉(zhuǎn)列表/元組
container_list = list(container)
container_tuple = tuple(container)

print("轉(zhuǎn)列表:", container_list)  # 輸出: [10, 20, 30]
print("轉(zhuǎn)元組:", container_tuple)  # 輸出: (10, 20, 30)

# 危險案例
original = [[1, 2], [3, 4]]
shallow_tuple = tuple(original)  # 僅外層轉(zhuǎn)元組

# 修改原始列表
original[0][0] = 99

print("淺轉(zhuǎn)換元組:", shallow_tuple)  # 輸出: ([99, 2], [3, 4]) → 意外修改！

import copy
safe_tuple = tuple(copy.deepcopy(item) for item in original)

# 錯誤示范
def add_item(item, items=tuple()):  # 元組作為默認(rèn)值
    items_list = list(items)  # 每次轉(zhuǎn)新列表
    items_list.append(item)
    return tuple(items_list)

print(add_item(1))  # 輸出: (1,)
print(add_item(2))  # 輸出: (2,) → 期望 (1,2) 但失??！

def add_item_fixed(item, items=None):
    if items is None:
        items = ()
    items_list = list(items)
    items_list.append(item)
    return tuple(items_list)

print(add_item_fixed(1))  # (1,)
print(add_item_fixed(2, (1,)))  # (1, 2)

# 示例
t1 = (1, [2, 3])  # 包含列表的元組 → 不可哈希！
try:
    {t1: "value"}
except TypeError as e:
    print("錯誤:", e)  # 'unhashable type: 'list''

# 修復(fù)：深度轉(zhuǎn)換內(nèi)部為元組
t2 = (1, tuple([2, 3]))
print({t2: "value"})  # 成功: {(1, (2, 3)): 'value'}

import timeit

# 小數(shù)據(jù)測試（10個元素）
small_list = list(range(10))
small_time = timeit.timeit('tuple(small_list)', 
                          globals={'small_list': small_list}, 
                          number=100000)

print(f"小列表轉(zhuǎn)元組（10萬次）: {small_time:.6f} 秒")  # 通常 < 0.01 秒

# 大數(shù)據(jù)測試（100萬元素）
large_list = list(range(1_000_000))
large_time = timeit.timeit('tuple(large_list)', 
                          globals={'large_list': large_list}, 
                          number=10)

print(f"大列表轉(zhuǎn)元組（10次）: {large_time:.6f} 秒")  # 通常 > 0.1 秒

from flask import request

@app.route('/submit', methods=['POST'])
def submit():
    # 獲取表單數(shù)據(jù)（元組形式）
    raw_data = request.form.items()  # 返回類似元組的列表
    
    # 轉(zhuǎn)為可修改列表
    data_list = [list(item) for item in raw_data]
    
    # 驗證與清理：移除空值
    cleaned = [item for item in data_list if item[1]]
    
    # 轉(zhuǎn)回元組準(zhǔn)備存儲（示例）
    final_data = tuple(tuple(item) for item in cleaned)
    
    return f"處理完成！數(shù)據(jù): {final_data}"

import pandas as pd

# 創(chuàng)建示例DataFrame
df = pd.DataFrame({"A": [1,2], "B": ["X","Y"]})

# 獲取命名元組迭代器
rows = df.itertuples(index=False)

# 轉(zhuǎn)列表進行批量操作
row_list = [list(row) for row in rows]

# 修改：添加新列
for row in row_list:
    row.append(row[0] * 10)  # 新列C = A*10

# 轉(zhuǎn)回DataFrame
new_df = pd.DataFrame(row_list, columns=["A", "B", "C"])
print(new_df)
#    A  B   C
# 0  1  X  10
# 1  2  Y  20

# 配置模塊
CONFIG = {
    "API_ENDPOINTS": [
        "https://api.service.com/v1",
        "https://api.service.com/v2"
    ]
}

# 轉(zhuǎn)為元組確保運行時安全
SAFE_CONFIG = {
    key: tuple(value) if isinstance(value, list) else value
    for key, value in CONFIG.items()
}

# 嘗試修改（失?。?
try:
    SAFE_CONFIG["API_ENDPOINTS"][0] = "hacked"
except TypeError:
    print("配置受保護！?")