《從零開始的Python筆記》Day#3:攻克Python資料結構

資料結構是程式設計的核心基石，直接影響演算法的效率與軟體設計的品質。在開發軟體工具時，選擇合適的資料結構不僅是解決問題的關鍵，也是實現高效與穩健程式的重要步驟。

Python 提供了多樣化的內建資料結構，每一種結構都針對特定的任務情境進行了優化設計。接下來，我們將深入探討這些資料結構的特性與用法，幫助你在實際開發中靈活運用。

🆕 字串(String)

• 不可變性 (Immutable)：字串一旦創建就無法被修改，所有看似的修改實際上是創建了一個新字串。
• 有序性 (Ordered)：字串中的字符是有序的，可以通過索引與切片來存取部分內容。
• 元素唯一類型：字串內部僅能存放字符（包括字母、數字、符號等），且本質上是一連串的字符序列。
• 可疊加操作：字串支援連接（+）、重複（\*）等操作，用於組合或生成新字串。
• 支持遍歷與切片：可以逐一遍歷字符，或通過索引範圍進行部分提取。
• 多種用途場景：廣泛用於文本處理、命令執行與數據格式化等領域。

索引與切片（Indexing & Slicing）

字串是由多個字符組成的序列，支援索引和切片操作以提取部分內容。

text = "Python Programming"

# 索引操作
print(text[0])  # 提取第一個字母
print(text[-1]) # 提取最後一個字母

# 切片操作
print(text[0:6])  # 提取 "Python"
print(text[7:])   # 提取 "Programming"

# 間隔數
print(text[0:6:2]) # 從0-6，間隔1字取值

# 字串反轉
print(text[::-1])

# 輸出
PgPythonProgrammingPtognimmargorP nohtyP

字串函數

Python 提供了許多內建函數來操作字串。

text = "   Hello, World!   "

# 字串長度
print(len(text))  # 取得字串長度

# 字串大小寫轉換
print(text.lower())  # 轉換為小寫
print(text.upper())  # 轉換為大寫

# 去除前後空格
print(text.strip())  # 去除前後多餘空白

# 拆分與合併
words = text.strip().split(", ")  # 拆分字串
print(words)
joined_text = " - ".join(words)   # 合併字串
print(joined_text)

# 輸出
18
hello, world!   HELLO, WORLD!   Hello, World!['Hello', 'World!']
Hello - World!

字串格式化：f-string

常搭配print()函數一起使用，可將各種變數也輸出在終端上。

name = "Alice"
age = 25
print(f"Hi, my name is {name} and I am {age} years old.")

# 輸出
Hi, my name is Alice and I am 25 years old.

字串進階函數

text = "Python is fun and powerful."

# 查找
print(f"子字串 'fun' 的索引: {text.find('fun')}") # 10

# 替換
new_text = text.replace("fun", "amazing")
print(new_text) # Python is amazing and powerful.

# 判斷開頭與結尾
print(text.startswith("Python")) # True
print(text.endswith("awesome")) # False

📋串列 (List)

列表 (list) 與元組 (tuple) 都是用來存放多個數據項的資料結構。它們在特性和使用方式上有一些關鍵差異。

• 可變性：列表是 可變的 (mutable)，可以隨時進行更改，例如新增、刪除或修改元素。
• 有序性：列表內的數據是有序的，可以通過索引定位數值，索引從 0 開始。
• 元素類型靈活：列表可以存放不同類型的資料（數字、字串、布林值、其他列表等）。
• 典型應用場景：適合用於需要頻繁更改數據的情況。

創建與操作

# 創建串列
fruits = ["apple", "banana", "cherry"]
print(fruits)

# 添加元素
fruits.append("orange")
print(fruits)

# 刪除元素
fruits.remove("banana")
print(fruits)

# 排序串列
fruits.sort()print(fruits)

# 輸出
['apple', 'banana', 'cherry']
['apple', 'banana', 'cherry', 'orange']
['apple', 'cherry', 'orange']
['apple', 'cherry', 'orange']

串列生成式（List Comprehension）

串列生成式（List Comprehension）是一種簡潔的 Python 語法，用於創建列表的方式。它可以用單行代碼快速生成新列表，代替傳統使用迴圈或函數操作的更多行代碼，同時可以包含條件篩選邏輯。

其基本的形式如下：

[<表達式> for <變數> in <可迭代對象> if <條件語句>]

串列生成式允許我們以簡單、直觀的方式從其他序列生成新列表，同時可以包含條件篩選邏輯。

優點：

• 簡潔易讀：串列生成式將迴圈和表達式結合在一行中，避免冗長的代碼結構，是 Python 強調「簡潔而有風格」理念的體現。
• 執行效率高：與使用明確迴圈創建列表相比，串列生成式通常執行速度更快，因為它是在 C 層級進行優化的。
• 減少代碼重複性：它將列表生成邏輯不需要反覆書寫的迴圈結構和條件篩選解決了，使代碼更加模組化與一致。

缺點：

• 可讀性降低：當邏輯過於複雜時（特別是嵌套條件或多重迴圈），串列生成式可能變得難以理解和維護。
• 無法完全取代傳統迴圈：復雜操作（如涉及多個變數的改變或需要進行多重操作排序）在串列生成式中難以實現且不直觀。這類情況下使用傳統的 for 迴圈更為適合。
• 消耗較多記憶體：串列生成式會一次性將所有生成的值保存到內存中，適用於小型數據集，不適用於非常大的列表（如幾百萬項）生成，這時應考慮使用生成器表達式。

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

# 一般寫法
squared = []  # 建立一個空列表，用來存放平方值
# 使用 for 迴圈逐一計算平方
for n in numbers:
    squared.append(n**2)  # 計算平方後加入列表

# 串列生成式
squared = [n**2 for n in numbers]  # 列表推導式：建立平方列表
print(squared)

# 輸出
[1, 4, 9, 16, 25]

🚇 元組 (Tuple)

元組 (tuple) 與列表 (list) 都是用來存放多個數據項的資料結構，要注意他們在特性上不同和相同的地方。

• 不可變性：元組是 不可變的 (immutable)，一旦創建後，元素無法被更改、刪除或重新指派。
• 有序性：元組內的數據是有序的，可以通過索引定位數值，索引從 0 開始。
• 元素類型靈活：元組可以包含不同類型的資料（如數字、字串、布林值等）。
• 性能更優：元組比列表佔用更小的記憶體，因為其不需要支援動態修改，適合存放不需更改的一組數據。
• 典型應用場景：適合用於數據不可改變的情況，如函數的返回多個值。

💡”不可變性”是最重要的特性!

# 建立元組
my_tuple = (1, 2, 3, "Python", True)
print(my_tuple)  # 輸出元組內容

# 元組不能修改（會報錯）
# my_tuple[2] = 99  # TypeError: 'tuple' object does not support item assignment

# 元組支持索引與切片
print(my_tuple[3])  # 提取第四個元素
print(my_tuple[:3]) # 提取前三個元素

# 輸出
(1, 2, 3, 'Python', True)
Python(1, 2, 3)

🗂️ 集合(Set)

集合 (set)是用來存儲 不重複元素 的無序集合。其操作靈活高效，特別在去重與集合運算領域有著廣泛應用。

基礎操作

# 建立集合
my_set = {1, 2, 3, 4}
print(my_set)  # {1, 2, 3, 4}

# 使用 set() 建立（支援從列表創建集合）
my_set = set([1, 2, 2, 3, "Python"])
print(my_set)  # {1, 2, 3, 'Python'} （重複值自動去重）

# 建立空集合
empty_set = set()
print(empty_set)  # set()

# 新增元素
my_set = {1, 2}
my_set.add(3)
print(my_set)  # {1, 2, 3}

# 刪除元素
my_set = {1, 2, 3}
my_set.remove(2)   # 正確刪除
print(my_set)   

# 輸出
{1, 2, 3, 4}
{1, 2, 3, 'Python'}
set()
{1, 2, 3}
{1, 3}

集合運算

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# 交集
print(set_a & set_b)  

# 聯集
print(set_a | set_b)  

# 差集
print(set_a - set_b)  

# 對稱集
print(set_a ^ set_b) 

# 輸出
{3, 4}
{1, 2, 3, 4, 5, 6}
{1, 2}
{1, 2, 5, 6}

📖 字典(Dictionary)

字典（dict）是 Python 中一種 鍵值對 (Key-Value Pairs) 的資料結構，可以根據鍵快速地查詢對應的值。字典是 Python 中經常使用的資料結構之一，其設計高效且應用廣泛。

• 鍵值對的映射：
• • 字典中的每個元素由「鍵 (Key)」和「值 (Value)」組成，形式為：key: value
  • 鍵是唯一的，不能有重複；值則可以重複
• 可變性 (Mutable)：
• • 字典是可變的，可以隨時新增、修改或刪除鍵值對
• 高效查找：
• • 字典透過哈希表實現，查詢速度非常快
• 鍵的要求：
• • 字典的鍵必須是 不可變 (Immutable) 的資料類型，例如字串、數字、元組，不能是列表或字典（這些是可變的）

建立字典

# 空字典
my_dict = {}# 包含鍵值對的字典
person = {"name": "Alice", "age": 25, "city": "New York"}
print(person)

# 輸出
{'name': 'Alice', 'age': 25, 'city': 'New York'}

取值

可以通過鍵來存取對應的值。如果鍵不存在，直接存取會引發 KeyError。

person = {"name": "Alice", "age": 25}

# 存取存在的鍵
print(person["name"])  

# 使用 get() 方法避免 KeyError
print(person.get("city", "Not Found")) 

 # 輸出
AliceNot Found

新增或修改鍵值對

person = {"name": "Alice", "age": 25}

# 新增鍵值對
person["city"] = "New York"
print(person)

# 修改鍵值對
person["age"] = 30
print(person)

# 輸出
{'name': 'Alice', 'age': 25, 'city': 'New York'}
{'name': 'Alice', 'age': 30, 'city': 'New York'}

刪除鍵值對

person = {"name": "Alice", "age": 30, "city": "New York"}

# 使用 del 刪除
del person["city"]
print(person)

# 使用 pop() 刪除並返回值
age = person.pop("age")
print(person)
print(f"Removed age: {age}")

# 輸出
{'name': 'Alice', 'age': 30}
{'name': 'Alice'}
Removed age: 30

字典遍歷

可以透過 keys()、values() 或 items() 完成鍵、值或鍵值對的迭代。

person = {"name": "Alice", "age": 30, "city": "New York"}

# 遍歷鍵
for key in person.keys():
    print(f"Key: {key}")

# 遍歷值
for value in person.values():
    print(f"Value: {value}")

# 遍歷鍵值對
for key, value in person.items():
    print(f"{key}: {value}")

# 輸出
Key: nameKey: ageKey: cityValue: AliceValue: 30
Value: New Yorkname: Aliceage: 30
city: New York

字典合併

dict_a = {"a": 1, "b": 2}
dict_b = {"c": 3, "d": 4}

# 使用 update()
dict_a.update(dict_b)print(dict_a)

# 使用字典解包語法（Python 3.9+）
merged_dict = {**dict_a, **dict_b}print(merged_dict)

# 輸出
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

🔍綜合比較

下表比較了 Python 中四種常見資料結構的功能差異與適用情境，幫助你在實際開發中做出最佳選擇。