Python 資料結構教學：List、Dict、Set、Tuple 一次搞懂

如果你曾經看著 AI 生成的程式碼裡一堆中括號和大括號發呆，這篇就是為你寫的。AI 回傳的資料幾乎都是結構化資料：API 回應通常是一個 dict，批次結果通常是一個 list。看不懂這些容器裝了什麼，你就只能照抄 AI 給的程式碼，卻抓不出它哪裡錯。

這篇會用範例帶你搞懂 Python 四種最常用的資料結構：list、dict、set、tuple，還有 AI 最愛寫也最容易寫錯的巢狀結構、推導式，以及兩個連資深工程師都會踩的陷阱。看完之後，你會多一個判斷 AI 給的程式碼對不對的能力。

串列 list：有序、可重複、可修改

list 是 Python 最常用的資料結構，用方括號 [] 包住，可以裝任何型別。AI 產出的程式九成以上都有 list，你要能讀懂它的增刪查改四個動作。

fruits = ["apple", "banana", "strawberry"]

# 取值（索引從 0 開始）
fruits[0]          # "apple"
fruits[-1]         # "strawberry"（最後一個）

# 新增
fruits.append("mango")     # 加到最後
fruits.insert(1, "grape")  # 插入指定位置

# 刪除
fruits.remove("banana")   # 刪除第一個符合的值
fruits.pop()              # 刪除並回傳最後一個
fruits.pop(0)              # 刪除並回傳第 0 個

# 查詢
"apple" in fruits       # True
fruits.index("strawberry")  # 2（回傳索引）
len(fruits)             # 元素數量

排序與切片：sort 跟 sorted 不一樣

nums = [3, 1, 4, 1, 5, 9]

nums.sort()              # 原地排序（改變自身）：[1,1,3,4,5,9]
sorted(nums)             # 回傳新串列（不改自身）
nums.sort(reverse=True)  # 反向排序
nums.reverse()           # 反轉串列

# 切片（回傳新 list，不改原始）
nums[1:4]               # 取索引 1~3
nums[::2]                # 每隔一個取一個
nums[::-1]               # 反轉（同 reverse 但不修改原串列）

# 複製 list（重要！）
a = [1, 2, 3]
b = a          # b 和 a 指向同一個 list！
c = a.copy()   # c 是獨立的複本
c = a[:]       # 同上，切片複製

a = [1, 2, 3]
b = a          # b 和 a 共用同一個 list
b.append(4)
print(a)       # [1, 2, 3, 4]（a 也被改了！）

字典 dict：key-value 配對

dict 用 {} 包住，每個元素是「key：value」配對。API 回應幾乎都是 dict 或 dict 的 list，這是最常接觸的結構。

user = {"name": "Joan", "age": 28, "city": "Taipei"}

# 取值
user["name"]             # "Joan"（key 不存在會拋 KeyError）
user.get("email")        # None（key 不存在回傳 None，不報錯）
user.get("email", "N/A")  # "N/A"（指定預設值）

# 新增 / 修改
user["email"] = "j@example.com"  # 新增 key
user["age"] = 29                  # 修改現有 key

# 刪除
del user["city"]          # 刪除指定 key
user.pop("age")           # 刪除並回傳值

# 遍歷
for key in user:                    # 遍歷所有 key
    print(key, user[key])
for k, v in user.items():          # 同時拿 key 和 value
    print(f"{k}: {v}")

dict 進階：合併、更新與推導式

d1 = {"a": 1, "b": 2}
d2 = {"b": 99, "c": 3}

# 合併（Python 3.9+）
merged = d1 | d2         # {"a":1, "b":99, "c":3}（d2 的 b 蓋掉 d1）

# 更新（就地）
d1.update(d2)            # d1 被更新，不回傳新 dict

# 取出所有 key / value / 配對
d1.keys()                # dict_keys(["a", "b"])
d1.values()              # dict_values([1, 2])
d1.items()               # dict_items([("a",1), ("b",2)])

# 判斷 key 存在
"a" in d1                # True（只查 key，不查 value）
1 in d1.values()          # True（查 value 要用 values 方法）

names = ["Alice", "Bob", "Carol"]

# 建立 {名字：名字長度} 的字典
name_len = {name: len(name) for name in names}
# {"Alice": 5, "Bob": 3, "Carol": 5}

d = {"name": "Joan", "age": 28}
print("Joan" in d)   # False！in 查的是 key，不是 value
print("name" in d)   # True

集合 set 與元組 tuple

set：無序、不重複，用來去重跟做集合運算

tags = {"Python", "AI", "Python"}   # 自動去重
print(tags)                          # {"Python", "AI"}（順序不固定）

# 新增 / 刪除
tags.add("Vibe")
tags.discard("AI")      # 不存在也不報錯（remove 會報錯）

# 集合運算
a = {1, 2, 3}
b = {2, 3, 4}
a & b                    # 交集：{2, 3}
a | b                    # 聯集：{1, 2, 3, 4}
a - b                    # 差集：{1}（在 a 但不在 b）

# 最常用：去除 list 重複值
names = ["Alice", "Bob", "Alice"]
unique = list(set(names))   # ["Alice", "Bob"]（順序不保證）

tuple：有序、不可修改，用來裝固定資料

point = (10, 20)          # 座標，不應被修改
x, y = point               # 解包（unpacking）

# 函式回傳多個值時，Python 自動打包成 tuple
def min_max(lst):
    return min(lst), max(lst)   # 回傳 tuple
lo, hi = min_max([3, 1, 4])     # 解包接收

巢狀結構與推導式

AI 回傳的 API 資料通常是「list 裡面裝 dict」的巢狀結構。推導式則讓你用一行取代四行迴圈，是 AI 最愛寫的簡潔語法。

巢狀結構：list of dict

students = [
    {"name": "Alice", "score": 92},
    {"name": "Bob",   "score": 78},
    {"name": "Carol", "score": 85},
]

# 取出第一個學生的名字
students[0]["name"]        # "Alice"

# 遍歷所有學生
for s in students:
    print(f"{s['name']}：{s['score']}")

串列推導式：一行取代 for 迴圈

nums = [1, 2, 3, 4, 5]

# 傳統寫法（五行）
squares = []
for n in nums:
    squares.append(n ** 2)

# 推導式（一行）
squares = [n ** 2 for n in nums]            # [1, 4, 9, 16, 25]
evens   = [n for n in nums if n % 2 == 0]   # [2, 4]（加條件）

# 取出所有學生名字（從 list of dict）
names = [s["name"] for s in students]       # ["Alice","Bob","Carol"]

AI 最容易踩的兩個資料結構陷阱

陷阱一：直接用 = 複製 list 或 dict（淺複製問題）

original = [1, 2, 3]
copy = original      # 同一個 list！
copy.append(4)
print(original)      # [1, 2, 3, 4]（原始也被改了）

copy = original.copy()  # 或 copy = list(original)
copy = original[:]      # 切片複製也可以

陷阱二：函式預設參數用 list 或 dict（可變預設參數）

def add_item(item, items=[]):   # [] 只建立一次！
    items.append(item)
    return items
print(add_item("a"))  # ["a"]
print(add_item("b"))  # ["a", "b"]（不是 ["b"]！）

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

三道遞進題：讀懂、改寫、抓錯

題目一　讀懂（基礎）

逐行說明以下程式碼在做什麼：說明 passed 和 result 分別是什麼結構、存了什麼值，並寫出 print 的輸出結果。

students = [
    {"name": "Alice", "score": 92},
    {"name": "Bob",   "score": 58},
    {"name": "Carol", "score": 75},
]
passed = [s["name"] for s in students if s["score"] >= 60]
result = {s["name"]: s["score"] for s in students}
print(passed)
print(result)

題目二　改寫（進階）

真實資料常有重複，AI 給的初版程式常用暴力 for 迴圈去重。懂得用 set 和 dict 去重，才能讓程式更快、更可靠，也能精準告訴 AI 該用哪種方式改寫。

# 原版：用 for 迴圈去重，效能較差
tags = ["Python", "AI", "Python", "Data", "AI"]
unique = []
for tag in tags:
    if tag not in unique:
        unique.append(tag)

任務：用以下提示詞請 AI 改寫，並說明改寫後的優缺點。

「請用三種方式改寫這段去重程式：
1. 用 set 去重（最快，但不保留順序）
2. 用 dict.fromkeys() 去重（保留順序）
3. 用 list 推導式加 seen set 去重（保留順序，最易讀）
每種方式加中文說明優缺點。」

題目三　抓錯（高階）

資料結構的錯誤很少直接崩潰，更常是悄悄產出錯誤結果：複製問題污染原始資料、KeyError 在邊界才爆出，是最難 debug 的一種。

def process_students(students, results={}):
    for s in students:
        name = s["name"]
        score = s["score"]
        results[name] = score
    return results

batch1 = [{"name": "Alice", "score": 92}]
batch2 = [{"name": "Bob",   "score": 78}]

r1 = process_students(batch1)
r2 = process_students(batch2)
print(r2)   # 你預期是什麼？

任務：找出兩個問題，說明 print(r2) 的實際輸出，並寫出修正提示詞。

術語速查表

重點整理與檢查清單

模組三完成清單

• 能說明 list、dict、set、tuple 的差異和各自用途
• 知道 .sort() 和 sorted() 的差別
• 知道 = 複製 list 是共用，要用 .copy()
• 能用 .get() 安全取 dict 值，避免 KeyError
• 看懂串列推導式和字典推導式
• 完成作業題目一：說明推導式的結構和輸出
• 完成作業題目二：用三種方式去重並說明優缺點
• 完成作業題目三：找出可變預設參數和 KeyError 問題