Langchain系列文章目錄

01-玩轉LangChain：從模型調用到Prompt模板與輸出解析的完整指南
02-玩轉 LangChain Memory 模塊：四種記憶類型詳解及應用場景全覆蓋
03-全面掌握 LangChain：從核心鏈條構建到動態任務分配的實戰指南
04-玩轉 LangChain：從文檔加載到高效問答系統構建的全程實戰
05-玩轉 LangChain：深度評估問答系統的三種高效方法（示例生成、手動評估與LLM輔助評估）
06-從 0 到 1 掌握 LangChain Agents：自定義工具 + LLM 打造智能工作流！
07-【深度解析】從GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【萬字長文】MCP深度解析：打通AI與世界的“USB-C”，模型上下文協議原理、實踐與未來

Python系列文章目錄

PyTorch系列文章目錄

機器學習系列文章目錄

深度學習系列文章目錄

Java系列文章目錄

JavaScript系列文章目錄

Python系列文章目錄

01-【Python-Day 1】告別編程恐懼：輕松掌握 Python 安裝與第一個程序的 6 個步驟
02-【Python-Day 2】掌握Python基石：變量、內存、標識符及int/float/bool數據類型
03-【Python-Day 3】玩轉文本：字符串(String)基礎操作詳解 (上)
04-【Python-Day 4】玩轉文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化輸出實戰：%、format()、f-string 對比與最佳實踐
06- 【Python-Day 6】從零精通 Python 運算符（上）：算術、賦值與比較運算全解析
07-【Python-Day 7】從零精通 Python 運算符（下）：邏輯、成員、身份運算與優先級規則全解析
08-【Python-Day 8】從入門到精通：Python 條件判斷 if-elif-else 語句全解析
09-【Python-Day 9】掌握循環利器：for 循環遍歷序列與可迭代對象詳解
10-【Python-Day 10】Python 循環控制流：while 循環詳解與 for 循環對比
11-【Python-Day 11】列表入門：Python 中最靈活的數據容器 (創建、索引、切片)
12-【Python-Day 12】Python列表進階：玩轉添加、刪除、排序與列表推導式
13-【Python-Day 13】Python 元組 (Tuple) 詳解：從創建、操作到高級應用場景一網打盡
14-【Python-Day 14】玩轉Python字典(上篇)：從零開始學習創建、訪問與操作
15-【Python-Day 15】深入探索 Python 字典 (下)：常用方法、遍歷、推導式與嵌套實戰

---

---

前言

在上一篇 【Python-Day 14】鍵值對的世界 - 字典 (Dictionary) 詳解 (上) 中，我們初步認識了 Python 中的字典，學習了如何創建字典、訪問、添加、修改和刪除鍵值對。字典作為一種極其重要的數據結構，其強大之處還遠不止于此。本篇我們將繼續深入，詳細探討字典的常用方法、高效的遍歷方式、簡潔的字典推導式以及如何處理更復雜的嵌套字典。掌握這些內容，你將能更自如地運用字典解決實際問題。

一、獲取字典的視圖：keys(), values(), items()

字典提供了三個非常實用的方法，用于獲取其內部元素的特定“視圖”(View Objects)：keys() 返回所有鍵的視圖，values() 返回所有值的視圖，而 items() 返回所有鍵值對（元組形式）的視圖。這些視圖對象是動態的，意味著如果原始字典發生改變，視圖也會相應地反映這些變化。

1.1 概覽與特性

字典視圖對象有以下幾個關鍵特性：

• 動態性：它們提供的是字典內容的動態視圖，而不是靜態副本。如果字典更新，視圖會實時反映這些變化。
• 可迭代性：所有視圖對象都是可迭代的，因此可以直接用于 for 循環。
• 類集合操作：keys() 和 items() 視圖支持一些集合操作，如并集、交集（如果元素可哈希）。values() 視圖通常不支持這些操作，因為它可能包含重復且不可哈希的元素。

讓我們通過一個例子來直觀感受一下：

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}
print(f"原始字典: {student_scores}") # 原始字典: {'Alice': 95, 'Bob': 88, 'Charlie': 92}keys_view = student_scores.keys()
values_view = student_scores.values()
items_view = student_scores.items()print(f"鍵視圖: {keys_view}")     # 鍵視圖: dict_keys(['Alice', 'Bob', 'Charlie'])
print(f"值視圖: {values_view}")   # 值視圖: dict_values([95, 88, 92])
print(f"項視圖: {items_view}")   # 項視圖: dict_items([('Alice', 95), ('Bob', 88), ('Charlie', 92)])# 修改字典
student_scores["David"] = 78
print(f"修改后字典: {student_scores}") # 修改后字典: {'Alice': 95, 'Bob': 88, 'Charlie': 92, 'David': 78}# 視圖會自動更新
print(f"更新后鍵視圖: {keys_view}")   # 更新后鍵視圖: dict_keys(['Alice', 'Bob', 'Charlie', 'David'])
print(f"更新后值視圖: {values_view}") # 更新后值視圖: dict_values([95, 88, 92, 78])
print(f"更新后項視圖: {items_view}") # 更新后項視圖: dict_items([('Alice', 95), ('Bob', 88), ('Charlie', 92), ('David', 78)])

1.2 獲取所有鍵：keys() 方法

keys() 方法返回一個包含字典所有鍵的視圖對象 (dict_keys)。

1.2.1 基本用法與示例

my_dict = {'name': 'CodeMaster', 'version': '1.0', 'language': 'Python'}
all_keys = my_dict.keys()
print(all_keys) # 輸出: dict_keys(['name', 'version', 'language'])# 可以將視圖轉換為列表
keys_list = list(all_keys)
print(keys_list) # 輸出: ['name', 'version', 'language']

1.2.2 keys() 返回的對象類型

返回的 dict_keys 對象是可迭代的，并且支持成員測試（in）。

if 'version' in all_keys:print("字典中包含 'version' 鍵。") # 輸出: 字典中包含 'version' 鍵。

1.3 獲取所有值：values() 方法

values() 方法返回一個包含字典所有值的視圖對象 (dict_values)。

1.3.1 基本用法與示例

my_dict = {'name': 'CodeMaster', 'version': '1.0', 'language': 'Python', 'score': 100}
all_values = my_dict.values()
print(all_values) # 輸出: dict_values(['CodeMaster', '1.0', 'Python', 100])# 同樣可以轉換為列表
values_list = list(all_values)
print(values_list) # 輸出: ['CodeMaster', '1.0', 'Python', 100]

1.3.2 values() 返回的對象類型

返回的 dict_values 對象也是可迭代的。需要注意的是，值視圖中可能包含重復的元素。

grades = {'math': 90, 'english': 95, 'history': 90}
student_values = grades.values()
print(student_values) # 輸出: dict_values([90, 95, 90])
print(list(student_values).count(90)) # 輸出: 2

1.4 獲取所有鍵值對：items() 方法

items() 方法返回一個包含字典所有鍵值對（以元組形式 (key, value)）的視圖對象 (dict_items)。

1.4.1 基本用法與示例

my_dict = {'name': 'CodeMaster', 'version': '1.0'}
all_items = my_dict.items()
print(all_items) # 輸出: dict_items([('name', 'CodeMaster'), ('version', '1.0')])# 轉換為列表，列表中的每個元素是一個元組
items_list = list(all_items)
print(items_list) # 輸出: [('name', 'CodeMaster'), ('version', '1.0')]

1.4.2 items() 返回的對象類型

dict_items 對象也是可迭代的，常用于同時遍歷鍵和值。

item_tuple = ('name', 'CodeMaster')
if item_tuple in all_items:print(f"{item_tuple} 存在于字典項中。") # 輸出: ('name', 'CodeMaster') 存在于字典項中。

二、玩轉字典遍歷

遍歷字典是日常編程中非常常見的操作。Python 提供了多種靈活的方式來遍歷字典的鍵、值或鍵值對。

2.1 遍歷字典的鍵

（1） 直接遍歷字典 (默認行為)

當你直接在 for 循環中使用字典時，默認遍歷的是字典的鍵。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("遍歷鍵 (默認行為):")
for name in student_scores:print(f"學生: {name}, 成績: {student_scores[name]}")
# 輸出:
# 遍歷鍵 (默認行為):
# 學生: Alice, 成績: 95
# 學生: Bob, 成績: 88
# 學生: Charlie, 成績: 92

（2） 使用 keys() 方法遍歷

顯式使用 keys() 方法也能達到同樣的效果，代碼意圖更清晰。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n使用 keys() 遍歷鍵:")
for name in student_scores.keys():print(f"學生: {name}")
# 輸出:
# 使用 keys() 遍歷鍵:
# 學生: Alice
# 學生: Bob
# 學生: Charlie

這種方式在需要先對鍵進行某些操作（如排序）后再遍歷時特別有用。

2.2 遍歷字典的值

（1） 使用 values() 方法遍歷

如果你只關心字典中的值，可以使用 values() 方法。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n遍歷值:")
for score in student_scores.values():print(f"成績: {score}")
# 輸出:
# 遍歷值:
# 成績: 95
# 成績: 88
# 成績: 92

2.3 遍歷字典的鍵值對

（1） 使用 items() 方法遍歷 (推薦)

當需要同時訪問鍵和值時，items() 方法是最佳選擇。它返回鍵值對元組，可以在 for 循環中直接解包。

student_scores = {"Alice": 95, "Bob": 88, "Charlie": 92}print("\n遍歷鍵值對 (推薦):")
for name, score in student_scores.items(): # 解包元組print(f"學生: {name}, 成績: {score}")
# 輸出:
# 遍歷鍵值對 (推薦):
# 學生: Alice, 成績: 95
# 學生: Bob, 成績: 88
# 學生: Charlie, 成績: 92

（2） 解包鍵值對

上面的 for name, score in student_scores.items(): 就是一個解包操作。items() 返回的每個元素是 (key, value) 形式的元組，通過 name, score 這樣的形式，Python 會自動將元組的第一個元素賦給 name，第二個元素賦給 score。

2.4 遍歷時的注意事項

在 Python 3.x 中，keys(), values(), items() 返回的是視圖對象。如果在遍歷字典視圖的同時修改字典（添加或刪除鍵），可能會導致 RuntimeError: dictionary changed size during iteration 錯誤，或者迭代行為不可預測。

通常建議的做法是：

1. 如果需要修改，先將視圖轉換為列表（如 list(my_dict.keys())），然后遍歷這個靜態列表。
2. 或者，創建一個新字典來存儲修改，而不是在原地修改。

# 錯誤示例：在遍歷時修改字典大小
# data = {'a': 1, 'b': 2, 'c': 3}
# for key in data.keys(): # data.keys() 是動態視圖
#     if data[key] % 2 == 0:
#         del data[key] # 這會改變字典大小，可能引發 RuntimeError# 正確做法1：遍歷鍵的副本
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
keys_to_delete = []
for key, value in data.items():if value % 2 == 0:keys_to_delete.append(key)for key in keys_to_delete:del data[key]
print(f"刪除偶數值后的字典: {data}") # 刪除偶數值后的字典: {'a': 1, 'c': 3}# 正確做法2: 創建新字典 (通常更推薦)
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
new_data = {}
for key, value in data.items():if value % 2 != 0: # 保留奇數值new_data[key] = value
print(f"只包含奇數值的新字典: {new_data}") # 只包含奇數值的新字典: {'a': 1, 'c': 3}

三、字典常用操作方法

除了視圖方法和基本的增刪改查，字典還有其他一些有用的內建方法。

3.1 檢查鍵是否存在：in 和 not in 運算符

我們已經在前面多次使用過 in 運算符來檢查一個鍵是否存在于字典中。這是判斷鍵是否存在的推薦方式，比嘗試訪問并捕獲 KeyError 更 Pythonic。

3.1.1 基本用法與示例

config = {"host": "localhost", "port": 8080, "debug_mode": True}key_to_check = "port"
if key_to_check in config:print(f"鍵 '{key_to_check}' 存在于字典中，值為: {config[key_to_check]}")
else:print(f"鍵 '{key_to_check}' 不存在于字典中。")
# 輸出: 鍵 'port' 存在于字典中，值為: 8080key_to_check = "username"
if key_to_check not in config:print(f"鍵 '{key_to_check}' 確實不存在于字典中。")
else:print(f"鍵 '{key_to_check}' 存在于字典中。")
# 輸出: 鍵 'username' 確實不存在于字典中。

3.1.2 與 get() 方法的比較

in 運算符用于檢查鍵的存在性，返回布爾值。而 get(key, default) 方法用于獲取鍵對應的值，如果鍵不存在，可以返回一個默認值（默認為 None），避免了 KeyError。

• 場景1：只想知道鍵是否存在？ 使用 in。
• 場景2：想獲取值，如果不存在則使用默認值？ 使用 get()。
• 場景3：想獲取值，如果不存在則報錯（明確要求鍵必須存在）？ 直接用 dict[key]。

config = {"host": "localhost"}# 使用 in
if "port" in config:port = config["port"]
else:port = 8000 # 默認值
print(f"端口號 (使用 in): {port}") # 端口號 (使用 in): 8000# 使用 get()
port = config.get("port", 8000) # 更簡潔
print(f"端口號 (使用 get()): {port}") # 端口號 (使用 get()): 8000# host 存在
host = config.get("host", "127.0.0.1")
print(f"主機 (使用 get()): {host}") # 主機 (使用 get()): localhost

3.2 合并字典：update() 方法

update() 方法用于將一個字典的鍵值對更新到另一個字典中。如果遇到相同的鍵，原字典中的值會被新字典中的值覆蓋。

3.2.1 使用另一個字典更新

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}dict1.update(dict2) # dict2 中的內容更新到 dict1
print(f"dict1 更新后: {dict1}") # dict1 更新后: {'a': 1, 'b': 3, 'c': 4}
# 注意：dict2 保持不變
print(f"dict2: {dict2}") # dict2: {'b': 3, 'c': 4}

3.2.2 使用可迭代的鍵值對更新

update() 方法不僅接受字典作為參數，還可以接受一個包含鍵值對元組的可迭代對象（如列表）。

user_profile = {'name': 'Alice'}
extra_info_list = [('age', 30), ('city', 'New York')]user_profile.update(extra_info_list)
print(f"更新后的用戶配置: {user_profile}")
# 輸出: 更新后的用戶配置: {'name': 'Alice', 'age': 30, 'city': 'New York'}# 也可以使用關鍵字參數
user_profile.update(country='USA', occupation='Engineer')
print(f"再次更新后的用戶配置: {user_profile}")
# 輸出: 再次更新后的用戶配置: {'name': 'Alice', 'age': 30, 'city': 'New York', 'country': 'USA', 'occupation': 'Engineer'}

3.2.3 處理鍵沖突

當使用 update() 合并字典時，如果參數字典中存在與原字典相同的鍵，則原字典中該鍵對應的值會被參數字典中的值所覆蓋。

settings_default = {'theme': 'light', 'fontsize': 12, 'language': 'en'}
user_settings = {'fontsize': 14, 'language': 'zh-CN', 'show_sidebar': True}settings_default.update(user_settings)
print(f"合并后的設置: {settings_default}")
# 輸出: 合并后的設置: {'theme': 'light', 'fontsize': 14, 'language': 'zh-CN', 'show_sidebar': True}
# 'fontsize' 和 'language' 被 user_settings 中的值覆蓋

從 Python 3.9 開始，還可以使用 | (并集) 操作符合并字典，它會創建一個新字典：

# Python 3.9+
dict_a = {'x': 1, 'y': 2}
dict_b = {'y': 3, 'z': 4}
merged_dict = dict_a | dict_b
print(f"使用 | 合并 (Python 3.9+): {merged_dict}") # 使用 | 合并 (Python 3.9+): {'x': 1, 'y': 3, 'z': 4}
# dict_a 和 dict_b 保持不變

四、字典推導式：簡潔創建與轉換字典

類似于列表推導式，Python 也支持字典推導式 (Dictionary Comprehension)，它提供了一種簡潔優雅的方式來創建字典。

4.1 什么是字典推導式？

字典推導式是一種基于現有可迭代對象（如列表、元組、集合，甚至另一個字典）來創建新字典的緊湊語法。它的基本結構是 {key_expr: value_expr for item in iterable if condition}。

4.2 基本語法與示例

4.2.1 從列表或元組創建字典

假設我們有一個名字列表，想創建一個字典，其中名字作為鍵，名字的長度作為值。

names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
print(f"名字長度字典: {name_lengths}")
# 輸出: 名字長度字典: {'Alice': 5, 'Bob': 3, 'Charlie': 7}

或者，從一個包含鍵值對元組的列表創建字典：

pairs = [("fruit", "apple"), ("color", "red"), ("count", 5)]
my_dict_from_pairs = {key: value for key, value in pairs}
print(f"從元組列表創建的字典: {my_dict_from_pairs}")
# 輸出: 從元組列表創建的字典: {'fruit': 'apple', 'color': 'red', 'count': 5}

4.2.2 基于現有字典創建新字典 (帶條件)

從一個現有字典中篩選元素或轉換鍵值來創建新字典。

scores = {"Math": 95, "English": 88, "Science": 92, "History": 75}# 創建一個只包含及格科目 (>=90) 的字典
passing_scores = {subject: score for subject, score in scores.items() if score >= 90}
print(f"及格科目: {passing_scores}")
# 輸出: 及格科目: {'Math': 95, 'Science': 92}# 創建一個將所有科目名稱轉為小寫的新字典
scores_lower = {subject.lower(): score for subject, score in scores.items()}
print(f"科目小寫字典: {scores_lower}")
# 輸出: 科目小寫字典: {'math': 95, 'english': 88, 'science': 92, 'history': 75}

4.2.3 鍵值互換

如果原字典的值是可哈希的（例如字符串、數字、元組），可以輕松地實現鍵值互換。

original_dict = {"a": 1, "b": 2, "c": 3}
# 確保值是唯一的，否則互換后會有鍵被覆蓋
swapped_dict = {value: key for key, value in original_dict.items()}
print(f"鍵值互換后的字典: {swapped_dict}")
# 輸出: 鍵值互換后的字典: {1: 'a', 2: 'b', 3: 'c'}# 如果值不唯一，后出現的會覆蓋前面的
non_unique_values = {"a": 1, "b": 2, "c": 1}
swapped_non_unique = {value: key for key, value in non_unique_values.items()}
print(f"值不唯一時鍵值互換: {swapped_non_unique}")
# 輸出: 值不唯一時鍵值互換: {1: 'c', 2: 'b'} (鍵 'a' 被 'c' 覆蓋，因為它們的值都是1)

4.3 字典推導式的優勢

• 簡潔性：相比使用 for 循環和手動添加鍵值對，字典推導式更為緊湊。
• 可讀性：一旦熟悉了語法，字典推導式能更清晰地表達創建字典的意圖。
• 效率：通常情況下，推導式的執行效率略高于等效的 for 循環（盡管對于初學者而言，可讀性優先）。

五、嵌套字典：構建復雜數據結構

當我們需要表示更復雜的數據結構時，例如一個學生信息系統，每個學生有多個屬性（姓名、年齡、成績等），這時就可以使用嵌套字典。即字典的值本身也是一個字典。

5.1 什么是嵌套字典？

嵌套字典是指一個字典的某些值是另一個字典。這允許我們創建層次化的數據結構。

5.2 創建嵌套字典

可以直接定義，也可以逐步構建。

# 直接定義
students_data = {"student_001": {"name": "Alice","age": 20,"courses": {"math": 95, "english": 88}},"student_002": {"name": "Bob","age": 22,"courses": {"math": 78, "history": 92}}
}
print(f"嵌套字典: {students_data}")
# 輸出:
# 嵌套字典: {'student_001': {'name': 'Alice', 'age': 20, 'courses': {'math': 95, 'english': 88}}, 'student_002': {'name': 'Bob', 'age': 22, 'courses': {'math': 78, 'history': 92}}}

5.3 訪問嵌套字典的元素

訪問嵌套字典的元素需要逐層使用鍵。

5.3.1 逐層訪問

# 獲取 Alice 的姓名
alice_name = students_data["student_001"]["name"]
print(f"Alice 的姓名: {alice_name}") # Alice 的姓名: Alice# 獲取 Bob 的數學成績
bob_math_score = students_data["student_002"]["courses"]["math"]
print(f"Bob 的數學成績: {bob_math_score}") # Bob 的數學成績: 78

5.3.2 使用 get() 方法安全訪問

為了避免因鍵不存在而引發 KeyError，尤其是在處理可能不完整的嵌套數據時，推薦使用 get() 方法。

# 嘗試獲取 Alice 的物理成績 (不存在)
alice_physics_score = students_data.get("student_001", {}).get("courses", {}).get("physics", "N/A")
print(f"Alice 的物理成績: {alice_physics_score}") # Alice 的物理成績: N/A# 解釋:
# students_data.get("student_001", {}) : 如果 "student_001" 存在，返回其值 (一個字典)；否則返回空字典 {}
# .get("courses", {})                  : 在上一步返回的字典中查找 "courses"；否則返回空字典 {}
# .get("physics", "N/A")               : 在上一步返回的字典中查找 "physics"；否則返回 "N/A"

這種鏈式 get() 調用是一種安全訪問深層嵌套值的常用模式。

5.4 修改嵌套字典的元素

修改嵌套字典的元素也需要先定位到該元素。

# 修改 Alice 的年齡
students_data["student_001"]["age"] = 21
print(f"修改后 Alice 的年齡: {students_data['student_001']['age']}") # 修改后 Alice 的年齡: 21# 給 Bob 添加一門新課程和成績
students_data["student_002"]["courses"]["science"] = 85
print(f"Bob 修改后的課程信息: {students_data['student_002']['courses']}")
# Bob 修改后的課程信息: {'math': 78, 'history': 92, 'science': 85}

5.5 遍歷嵌套字典

遍歷嵌套字典通常需要使用嵌套循環。

print("\n遍歷所有學生信息:")
for student_id, info in students_data.items():print(f"學生ID: {student_id}")for key, value in info.items():if isinstance(value, dict): # 如果值本身也是字典 (如 courses)print(f"  {key}:")for sub_key, sub_value in value.items():print(f"    {sub_key}: {sub_value}")else:print(f"  {key}: {value}")print("-" * 20) # 分隔符# 輸出:
# 遍歷所有學生信息:
# 學生ID: student_001
#   name: Alice
#   age: 21
#   courses:
#     math: 95
#     english: 88
# --------------------
# 學生ID: student_002
#   name: Bob
#   age: 22
#   courses:
#     math: 78
#     history: 92
#     science: 85
# --------------------

對于任意深度的嵌套字典，可能需要遞歸函數來進行遍歷。

六、總結

本篇文章我們深入學習了 Python 字典的更多高級和常用操作，這些是高效使用字典的關鍵：

1. 字典視圖：keys()、values() 和 items() 方法提供了字典鍵、值和鍵值對的動態視圖，它們是可迭代的，并能實時反映字典的變化。
2. 高效遍歷：掌握了如何分別遍歷字典的鍵、值以及鍵值對，特別是使用 items() 配合解包來同時訪問鍵和值是最常用的方式。同時注意到了遍歷時修改字典的潛在問題及應對策略。
3. 常用方法：學習了使用 in 運算符檢查鍵是否存在，以及 update() 方法合并字典的多種方式，包括處理鍵沖突和 Python 3.9+ 的 | 操作符。
4. 字典推導式：掌握了使用字典推導式從可迭代對象簡潔、高效地創建和轉換字典，包括添加條件和鍵值互換等操作。
5. 嵌套字典：理解了如何創建、訪問、修改和遍歷嵌套字典，以表示更復雜和層次化的數據結構，并學會了使用 get() 方法進行安全訪問。

通過這兩篇文章的學習，你現在應該對 Python 字典的創建、基本操作、常用方法、遍歷技巧以及高級應用（如推導式和嵌套）有了全面而深入的理解。字典是 Python 中用途最廣泛的數據結構之一，熟練掌握它將極大提升你的編程效率和代碼質量。在后續的學習和實踐中，你會越來越體會到字典的強大與便捷。

---