字典(Dictionary)

创建字典

# 方式1:使用花括号 {} 和键值对
dict1 = {"name": "Alice", "age": 20, "city": "Beijing"}

# 方式2：使用 dict() 构建函数，这种方式要求键是有效的标识符（通常是字符串）
dict2 = dict(name="Alice", age=20, city="Beijing")

# 方式3：使用键值对的序列（如列表或元组）
dict3 = dict([("name", "Alice"), ("age", 20), ("city", "Beijing")])
dict4 = dict(zip(["name", "age", "city"], ["Alice", 20, "Beijing"]))

# 方式4：创建空字典
empty_dict1 = {}
empty_dict2 = dict()

查

方法	作用
dict[key]	获取键对应的值，键不存在则抛 KeyError
dict.get()	获取键对应的值，键不存在则返回默认值（默认值省略则返回 None）
dict.keys()	返回所有键的视图对象（可迭代）
dict.values()	返回所有值的视图对象（可迭代）
dict.items()	返回所有键值对的视图对象（每个元素是 (键，值) 元组，可迭代）

student = {"name": "小明", "age": 20, "city": "北京"}

# 1. [] 取值（有风险）
print(student["name"])      # 输出: 小明
# print(student["height"])  # 报错: KeyError

# 2. get() 安全取值
print(student.get("height"))        # 输出: None
print(student.get("height", 175))   # 输出: 175

# 3. 查看所有键/值/键值对
print(list(student.keys()))     # 输出: ['name', 'age', 'city']
print(list(student.values()))   # 输出: ['小明', 20, '北京']
print(list(student.items()))    # 输出: [('name', '小明'), ('age', 20), ('city', '北京')]

# 检查键是否存在：使用in关键字
if "age" in person:
  pring("Age is persent")

删

方法	作用
del dict[key]	删除指定键值对，键不存在则抛 KeyError
dict.pop()	删除指定键值对并返回对应值，键不存在则返回默认值（无默认值则抛错）
dict.popitem()	删除并返回最后插入的键值对（Python 3.7+ 有序），空字典抛 KeyError
dict.clear()	清空字典所有键值对，字典变为空

student = {"name": "小明", "age": 20, "city": "北京"}

# 1. del 删除
del student["city"]
print(student)  # 输出: {'name': '小明', 'age': 20}

# 2. pop() 删除并返回值
age = student.pop("age")
print(age)       # 输出: 20
print(student)   # 输出: {'name': '小明'}
# student.pop("height")  # 报错: KeyError
print(student.pop("height", "未知"))  # 输出: 未知

# 3. popitem() 删除最后一个键值对
student["gender"] = "男"
kv = student.popitem()
print(kv)        # 输出: ('gender', '男')
print(student)   # 输出: {'name': '小明'}

# 4. clear() 清空
student.clear()
print(student)   # 输出: {}

增/改

方法	作用
dict[key] = value	新增键值对（键不存在）或修改值（键已存在）
dict.update()	批量添加 / 修改键值对，参数可以是字典、包含双元素的列表 / 元组等
dict.setdefault()	若键不存在，新增键值对（值为默认值）；若存在，返回原有值（不修改）

# 1. 基础增/改
student = {"name": "小明", "age": 18}
student["gender"] = "男"  # 新增键值对
student["age"] = 19       # 修改已有键的值
print(student)  # 输出: {'name': '小明', 'age': 19, 'gender': '男'}

# 2. update() 批量操作
student.update({"score": 90, "age": 20})  # 批量修改+新增
student.update([("city", "北京"), ("grade", "高三")])  # 可迭代对象作为参数
print(student)  # 输出: {'name': '小明', 'age': 20, 'gender': '男', 'score': 90, 'city': '北京', 'grade': '高三'}

# 3. setdefault() 安全新增（避免覆盖）
student.setdefault("hobby", "篮球")  # 键不存在，新增
student.setdefault("age", 18)        # 键存在，返回原有值（20），不修改
print(student["hobby"])  # 输出: 篮球
print(student["age"])    # 输出: 20

遍历/转换

方法	作用
dict.copy()	返回字典的浅拷贝（新字典，修改新字典不影响原字典，嵌套结构除外）
dict.fromkeys()	类方法，创建新字典：以可迭代对象元素为键，所有键的默认值相同（默认 None）

# 1. copy() 浅拷贝
dict1 = {"a": 1, "b": [2, 3]}
dict2 = dict1.copy()
dict2["a"] = 100        # 修改非嵌套值，原字典不受影响
dict2["b"].append(4)    # 修改嵌套列表，原字典受影响（浅拷贝特性）
print(dict1)  # 输出: {'a': 1, 'b': [2, 3, 4]}
print(dict2)  # 输出: {'a': 100, 'b': [2, 3, 4]}

# 2. fromkeys() 创建新字典
keys = ["name", "age", "city"]
new_dict = dict.fromkeys(keys)       # 默认值 None
new_dict2 = dict.fromkeys(keys, "未知")  # 所有键值为 "未知"
print(new_dict)   # 输出: {'name': None, 'age': None, 'city': None}
print(new_dict2)  # 输出: {'name': '未知', 'age': '未知', 'city': '未知'}

字典推导式

替代 for 循环 +update()，简洁高效地创建或筛选字典。

# 1. 基础推导式：从列表生成字典
nums = [1, 2, 3, 4]
square_dict = {num: num*num for num in nums}
print(square_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16}

# 2. 过滤推导式：保留值大于 10 的键值对
score_dict = {"语文": 85, "数学": 95, "英语": 88, "物理": 92}
high_score = {k: v for k, v in score_dict.items() if v >= 90}
print(high_score)  # 输出: {'数学': 95, '物理': 92}

# 3. 多字典合并推导式（Python 3.5+）
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict = {**dict1, **dict2}  # 等同于 dict1 | dict2（3.9+）
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

字典深拷贝

原生 dict.copy() 是浅拷贝，嵌套可变对象（如列表、字典）修改会互相影响，需用 copy 模块的 deepcopy。

import copy

# 浅拷贝问题：嵌套列表被修改，原字典也变
dict1 = {"a": 1, "b": [2, 3]}
dict2 = dict1.copy()
dict2["b"].append(4)
print(dict1["b"])  # 输出: [2, 3, 4]

# 深拷贝：完全独立，嵌套对象也复制
dict3 = copy.deepcopy(dict1)
dict3["b"].append(5)
print(dict1["b"])  # 输出: [2, 3, 4]（原字典不受影响）
print(dict3["b"])  # 输出: [2, 3, 4, 5]

字典解包：函数参数/批量赋值

用 ** 解包字典为关键字参数，或用 items() 批量赋值。

# 1. 函数参数解包
def print_student(name, age, city):
    print(f"姓名：{name}，年龄：{age}，城市：{city}")

student = {"name": "小明", "age": 20, "city": "北京"}
print_student(**student)  # 等价于 print_student(name="小明", age=20, city="北京")
# 输出: 姓名：小明，年龄：20，城市：北京

# 2. 批量赋值
kv_pairs = [("a", 1), ("b", 2), ("c", 3)]
new_dict = dict(kv_pairs)
print(new_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

字典比较与排序

原生字典可直接用==比较（键值对完全相同则相等），排序需结合sorted()

# 1. 字典比较
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 2, "a": 1}
print(dict1 == dict2)  # 输出: True（键值对相同，顺序无关）

# 2. 按值排序（返回列表，需转回字典）
score_dict = {"语文": 85, "数学": 95, "英语": 88}
# 按值升序
sorted_by_value = dict(sorted(score_dict.items(), key=lambda x: x[1]))
print(sorted_by_value)  # 输出: {'语文': 85, '英语': 88, '数学': 95}
# 按值降序
sorted_by_value_desc = dict(sorted(score_dict.items(), key=lambda x: x[1], reverse=True))
print(sorted_by_value_desc)  # 输出: {'数学': 95, '英语': 88, '语文': 85}

内置模块

collections 模块

Python 内置的 collections 模块提供了多个「增强版字典」，解决原生字典的痛点（如默认值、有序、计数等）。

扩展类型 / 方法	作用
collections.defaultdict	带默认值的字典：访问不存在的键时，自动创建并赋予指定默认值（无需频繁用 get()）
collections.OrderedDict	有序字典（Python 3.7+ 原生字典已有序，但它提供额外排序 / 移动方法）
collections.Counter	计数字典：专门用于统计可哈希对象的出现次数（键是元素，值是次数）
collections.ChainMap	链式字典：将多个字典合并为一个视图，查询时按顺序遍历字典（不复制数据）

from collections import defaultdict, OrderedDict, Counter, ChainMap

# 1. defaultdict：自动生成默认值
# 场景：统计列表中元素出现的次数（避免手动判断键是否存在）
nums = [1, 2, 2, 3, 3, 3]
count_dict = defaultdict(int)  # 默认值为 int 类型（0）
for num in nums:
    count_dict[num] += 1
print(dict(count_dict))  # 输出: {1: 1, 2: 2, 3: 3}

# 嵌套字典的默认值（如 value 是列表）
user_dict = defaultdict(list)
user_dict["小明"].append("语文90")
user_dict["小明"].append("数学85")
print(dict(user_dict))  # 输出: {'小明': ['语文90', '数学85']}

# 2. OrderedDict：有序+额外方法（Python 3.7+ 原生字典有序，但它有 move_to_end 等方法）
od = OrderedDict({"a": 1, "b": 2, "c": 3})
od.move_to_end("a")  # 将键 "a" 移到末尾
print(list(od.keys()))  # 输出: ['b', 'c', 'a']
od.move_to_end("c", last=False)  # 将键 "c" 移到开头
print(list(od.keys()))  # 输出: ['c', 'b', 'a']

# 3. Counter：快速计数
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
word_count = Counter(words)
print(word_count)  # 输出: Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(word_count.most_common(2))  # 取前 2 个高频元素：[('apple', 3), ('banana', 2)]

# 4. ChainMap：合并多个字典（视图，不复制）
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
cm = ChainMap(dict1, dict2)
print(cm["a"])  # 输出: 1（取第一个字典的键）
print(cm["b"])  # 输出: 2（优先第一个字典，即使第二个有重复键）
print(cm["c"])  # 输出: 4

operator 模块

operator 模块提供了便捷的字典操作函数，替代 lambda 表达式，更高效且易读。

方法	作用
operator.itemgetter(key)	创建函数，用于快速获取字典的指定键值（常用于排序）
operator.attrgetter	（间接）若字典值是对象，可快速获取对象属性

import operator

# 场景：对字典列表按指定键排序（如按 age 排序）
students = [
    {"name": "小明", "age": 20},
    {"name": "小红", "age": 18},
    {"name": "小刚", "age": 19}
]

# 用 itemgetter 按 age 升序排序（比 lambda 更高效）
sorted_students = sorted(students, key=operator.itemgetter("age"))
print(sorted_students)
# 输出: [{'name': '小红', 'age': 18}, {'name': '小刚', 'age': 19}, {'name': '小明', 'age': 20}]

# 也可按多个键排序（先 age，再 name）
students2 = [
    {"name": "小明", "age": 19},
    {"name": "小红", "age": 18},
    {"name": "小刚", "age": 19}
]
sorted_students2 = sorted(students2, key=operator.itemgetter("age", "name"))
print(sorted_students2)
# 输出: [{'name': '小红', 'age': 18}, {'name': '小刚', 'age': 19}, {'name': '小明', 'age': 19}]

第三方库扩展

• json：字典与 JSON 字符串互转（网络传输/文件存储）；

• pandas：将字典转为 DataFrame（数据分析场景）；

• deepdiff：对比两个字典的差异（如接口返回值校验）

• ruamel.yaml：字典与 YAML 格式互转（配置文件场景）；