定義

字典（dict）是一種無序、可變且可哈希的數據結構，字典是根據一個信息來查找另一個信息，它表示索引用的鍵和對應的值構成的成對關系。

特點

（1）字典與列表一樣，是Python里面的可變數據類型。

（2）鍵必須唯一且不可變（如字符串、數字、元組），值可以是任意類型。

（3）有無序性。

（4）基于哈希表實現，支持高效查找，查找插入和刪除操作的時間復雜度接近 O (1)。

字典的創建方式

一、使用 {} 直接創建字典

語法格式：

d = {key1: value1, key2: value2, ...}  

1、用大括號 { } 包裹鍵值對（key: value 形式），多個鍵值對用逗號 , 分隔。
2、鍵（key）：必須是不可變類型（如字符串、數字、元組），且字典內鍵唯一；
3、值（value）：可以是任意 Python 數據類型（字符串、數字、列表、字典等都行）。

示例：?

# 直接用 {} 定義字典，存儲學生信息  
student = {"name": "小明",   # 鍵 "name" 是字符串，值 "小明" 是字符串  "age": 15,       # 鍵 "age" 是字符串，值 15 是整數  "hobbies": ["籃球", "音樂"]  # 鍵 "hobbies" 是字符串，值是列表  
}  print(student)  
# 輸出: {'name': '小明', 'age': 15, 'hobbies': ['籃球', '音樂']}  

?二、用內置函數 dict() 創建字典

1. 直接傳 key=value 形式參數

語法格式：

d = dict(key1=value1, key2=value2, ...)  

說明：

（1）括號里用 key=value 形式傳參（類似函數傳參），Python 會自動把這些參數轉為字典的鍵值對.

（2）這里的 key 不用加引號（本質是參數名），但實際存到字典里會變成字符串類型的鍵。?

?示例：

# 用 dict() + key=value 形式創建字典  
person = dict(name="小紅", age=20, city="北京")  print(person)  
# 輸出: {'name': '小紅', 'age': 20, 'city': '北京'}  

?2. 結合 zip() 映射創建字典（“通過映射函數創建” 本質就是這用法）

語法格式：

# 先用 zip(lst1, lst2) 把兩個列表 “配對”，再用 dict() 轉成字典  
d = dict(zip(lst1, lst2))  

（1）zip(lst1, lst2)：把兩個列表 對應位置的元素 打包成元組，返回一個可迭代的 zip 對象。比如 lst1 = [10,20]、lst2 = ["cat","bar"]，zip 后會得到 (10, 'cat'), (20, 'bar')。

（2）dict() 會把這些元組里的 第一個元素當鍵、第二個元素當值，最終轉成字典。?

示例：

lst1 = [10, 20, 30, 40]  
lst2 = ["cat", "bar", "zoo", "pat"]  # 1. 用 zip 配對兩個列表  
zipped = zip(lst1, lst2)  
# 此時 zipped 是可迭代對象，內容類似: (10, 'cat'), (20, 'bar'), (30, 'zoo'), (40, 'pat')  # 2. 用 dict() 轉成字典  
result = dict(zipped)  print(result)  
# 輸出: {10: 'cat', 20: 'bar', 30: 'zoo', 40: 'pat'}  

?**重點：

（1）lst1 里的元素會作為字典的 鍵，必須保證不可變且唯一（如果 lst1 有重復元素，后面的會覆蓋前面的）。

（2）lst2 里的元素是字典的 值，類型無限制。

（3）如果兩個列表長度不一致，zip 會以 較短的列表為準，多余元素會被忽略。

字典的訪問

1、使用 d[key]

通過鍵直接訪問對應的值。

缺點：如果鍵不存在，會拋出 KeyError 異常。

print(d['hello'])  # 輸出: 10
# print(d['java'])  # 報錯: KeyError: 'java'

2、使用 d.get(key, default=None)

通過鍵獲取值，若鍵不存在則返回默認值（默認為 None）。

優點：避免 KeyError，增強代碼健壯性。?

print(d.get('hello'))        # 輸出: 10
print(d.get('java'))         # 輸出: None（默認值）
print(d.get('java', '不存在'))  # 輸出: '不存在'（自定義默認值）

?

字典的遍歷

1、使用字典（Dictionary）類型的一個內置方法 items()

語法格式

dict.items()

dict 表示一個具體的字典對象，比如 my_dict = {'key1': 'value1', 'key2': 'value2'}，my_dict.items()的 my_dict 就是字典對象。items() 方法會返回一個包含字典所有鍵值對的視圖對象（dict_items類型），這個視圖對象是可迭代的，其中每個元素都是一個由鍵和值組成的元組。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
result = my_dict.items()
print(result)
# 輸出: dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

items() 方法通常h結合循環使用

# 字典的遍歷
for item in d.items():print(item)  # key=value組成的一個元素

?

2、解包遍歷（分別獲取 key 和 value ）?

# 在使用for循環遍歷時，分別獲取key,value
for key, value in d.items():print(key, value)

?

字典的一些相關操作

示例

my_dict = {'name': '小明', 'age': 18, 'city': '北京'}# 1、d.keys()：獲取所有的 key 數據keys = my_dict.keys()
print(keys)
# 輸出（Python 3 中返回可迭代的 dict_keys 對象，便于遍歷等操作 ）：
# dict_keys(['name', 'age', 'city'])
# 可轉成列表直觀查看
print(list(keys))  
# 輸出: ['name', 'age', 'city']# 2、d.values()：獲取所有的 value 數據values = my_dict.values()
print(values)
# 輸出（返回 dict_values 對象 ）：
# dict_values(['小明', 18, '北京'])
# 轉列表
print(list(values))  
# 輸出: ['小明', 18, '北京']# 3、d.pop(key, default)：根據 key 獲取 value 并刪除鍵值對，不存在則用默認值# key 存在的情況
age_value = my_dict.pop('age', '默認值')
print(age_value)  
# 輸出: 18 ，同時 my_dict 里的 'age': 18 被刪除
print(my_dict)  
# 輸出: {'name': '小明', 'city': '北京'}
# key 不存在的情況
gender_value = my_dict.pop('gender', '未知')
print(gender_value)  
# 輸出: '未知' ，因為字典里沒有 'gender' 這個 key# 4、d.popitem()：隨機取出一個 key - value 對（Python 3.7+ 后默認按插入順序，逆序彈出 ）item = my_dict.popitem()
print(item)  
# 比如可能輸出 ('city', '北京') ，具體取決于字典當前狀態，彈出后該鍵值對從字典刪除
print(my_dict)  
# 彈出后字典內容如: {'name': '小明'} # 5、d.clear()：清空字典所有 key - value 對my_dict.clear()
print(my_dict)  
# 輸出: {} ，字典變成空字典

字典生成式

1、借助 range 構建簡單映射（需明確 key、value 邏輯）

# 示例：用 range 生成字典，這里假設 key 是數字，value 是其平方（可按需改 key:value 邏輯）
d = {item: item**2 for item in range(5)}  
print(d)
# 輸出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

item 來自 range 遍歷，key:value 是自定義的映射規則（比如示例里 item 做 key，item**2 做 value ）?

2、用 zip 關聯兩個列表生成字典（適合數據配對場景）

lst1 = ['a', 'b', 'c']
lst2 = [1, 2, 3]
d = {key: value for key, value in zip(lst1, lst2)}  
print(d)
# 輸出: {'a': 1, 'b': 2, 'c': 3}

利用 zip(lst1, lst2) 把兩個列表對應位置元素打包成元組，遍歷元組時拆出 key（來自 lst1 ）和 value（來自 lst2 ）構建字典 。

關于字典的內容就到這里啦~~

感謝觀看！！?

?