定义

字典（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 ）构建字典 。

关于字典的内容就到这里啦~~

感谢观看！！