100道题搞定Python3字典操作：入门必备，进阶必练

原创 已于 2025-10-11 12:21:23 修改 · 499 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #算法 #java #pip

于 2025-10-11 10:38:58 首次发布

文章目录

100道题搞定Python3字典操作：入门必备，进阶必练

以下是100个Python3字典练习题的详解与代码示例，涵盖字典创建、访问、修改、删除、遍历、推导式、嵌套字典等核心知识点，由浅入深排列，适合入门学习。

一、字典基础（1-10）

1. 题目：创建空字典

需求：创建一个空字典，并打印其类型和内容。

empty_dict = {}
# 或使用dict()函数
# empty_dict = dict()
print(type(empty_dict))  # 输出：<class 'dict'>
print(empty_dict)        # 输出：{}

解析：字典用{}或dict()创建，是存储键值对（key-value）的无序（Python 3.7+有序）数据结构，键必须唯一且不可变（如字符串、数字、元组）。

2. 题目：创建带初始键值对的字典

需求：创建包含姓名、年龄、职业的字典，如{"name": "张三", "age": 18, "job": "学生"}。

person = {
    "name": "张三",
    "age": 18,
    "job": "学生"
}
print(person)  # 输出：{'name': '张三', 'age': 18, 'job': '学生'}

解析：字典由键值对组成，格式为{key1: value1, key2: value2, ...}，键与值用冒号分隔，键值对之间用逗号分隔。

3. 题目：通过键访问字典的值

需求：从字典{"name": "李四", "age": 20}中获取姓名的值。

person = {"name": "李四", "age": 20}
print(person["name"])  # 输出：李四

解析：通过字典名[key]访问对应的值，若键不存在会抛出KeyError。

4. 题目：使用get()方法访问值

需求：从字典{"city": "北京", "country": "中国"}中获取"city"的值，若"zipcode"不存在则返回默认值"未知"。

location = {"city": "北京", "country": "中国"}
# 获取存在的键
print(location.get("city"))  # 输出：北京
# 获取不存在的键，返回默认值
print(location.get("zipcode", "未知"))  # 输出：未知

解析：dict.get(key, default)方法访问值，键不存在时返回default（默认None），避免KeyError。

5. 题目：修改字典中的值

需求：将字典{"price": 100, "name": "手机"}中的价格修改为150。

product = {"price": 100, "name": "手机"}
product["price"] = 150  # 通过键修改值
print(product)  # 输出：{'price': 150, 'name': '手机'}

解析：字典是可变对象，通过字典名[key] = 新值可直接修改对应的值。

6. 题目：向字典添加新键值对

需求：向字典{"name": "电脑"}中添加"brand": “联想"和"price”: 5000。

product = {"name": "电脑"}
product["brand"] = "联想"  # 添加新键值对
product["price"] = 5000
print(product)  # 输出：{'name': '电脑', 'brand': '联想', 'price': 5000}

解析：为字典中不存在的键赋值，会自动添加该键值对。

7. 题目：删除字典中的键值对

需求：从字典{"a": 1, "b": 2, "c": 3}中删除键"b"。

my_dict = {"a": 1, "b": 2, "c": 3}
del my_dict["b"]  # 删除键"b"对应的键值对
print(my_dict)  # 输出：{'a': 1, 'c': 3}

解析：del语句可删除字典中指定键的键值对，若键不存在会抛KeyError。

8. 题目：获取字典中键的列表

需求：获取字典{"name": "张三", "age": 18}中所有键的列表。

person = {"name": "张三", "age": 18}
keys = list(person.keys())  # keys()返回键视图，转为列表
print(keys)  # 输出：['name', 'age']

解析：dict.keys()返回包含所有键的视图对象，用list()可转为列表（Python 3.7+保留插入顺序）。

9. 题目：获取字典中值的列表

需求：获取字典{"math": 90, "english": 85}中所有值的列表。

scores = {"math": 90, "english": 85}
values = list(scores.values())  # values()返回值视图，转为列表
print(values)  # 输出：[90, 85]

解析：dict.values()返回包含所有值的视图对象，转为列表后可查看所有值。

10. 题目：判断键是否在字典中

需求：检查"age"是否在字典{"name": "李四", "age": 20}中。

person = {"name": "李四", "age": 20}
print("age" in person)      # 输出：True（检查键是否存在）
print("gender" in person)   # 输出：False

解析：in关键字用于判断键是否存在于字典中，返回布尔值；not in判断键是否不存在。

二、字典方法与操作（11-30）

11. 题目：使用pop()方法删除键值对并返回值

需求：从字典{"a": 1, "b": 2}中删除键"a"，并返回其值。

my_dict = {"a": 1, "b": 2}
value = my_dict.pop("a")  # 删除键"a"并返回其值
print(value)    # 输出：1
print(my_dict)  # 输出：{'b': 2}

解析：dict.pop(key)删除指定键并返回对应值，键不存在会抛KeyError；可指定默认值dict.pop(key, default)避免报错。

12. 题目：使用popitem()方法删除最后一个键值对

需求：删除字典{"x": 10, "y": 20, "z": 30}中最后一个键值对，并返回该键值对。

coords = {"x": 10, "y": 20, "z": 30}
item = coords.popitem()  # 删除最后一个键值对（Python 3.7+按插入顺序）
print(item)     # 输出：('z', 30)
print(coords)   # 输出：{'x': 10, 'y': 20}

解析：dict.popitem()删除并返回字典中最后一个键值对（元组形式），空字典调用会抛KeyError。

13. 题目：使用update()方法合并字典

需求：将字典{"b": 2, "c": 3}合并到{"a": 1}中。

dict1 = {"a": 1}
dict2 = {"b": 2, "c": 3}
dict1.update(dict2)  # 将dict2的键值对添加到dict1
print(dict1)  # 输出：{'a': 1, 'b': 2, 'c': 3}

解析：dict1.update(dict2)将dict2的键值对添加到dict1，若有相同键则覆盖dict1的值。

14. 题目：使用clear()方法清空字典

需求：清空字典{"name": "张三", "age": 18}中的所有键值对。

person = {"name": "张三", "age": 18}
person.clear()  # 清空字典
print(person)  # 输出：{}

解析：dict.clear()删除字典中所有键值对，保留字典对象本身（与del删除对象不同）。

15. 题目：使用copy()方法复制字典

需求：创建字典{"a": 1, "b": 2}的副本，修改副本不影响原字典。

original = {"a": 1, "b": 2}
copy_dict = original.copy()  # 浅拷贝
copy_dict["a"] = 99
print(original)  # 输出：{'a': 1, 'b': 2}（原字典不变）
print(copy_dict) # 输出：{'a': 99, 'b': 2}

解析：dict.copy()创建字典的浅拷贝，副本与原字典独立，修改副本不会影响原字典。

16. 题目：使用fromkeys()创建字典

需求：以列表["name", "age", "gender"]为键，默认值为None创建字典。

keys = ["name", "age", "gender"]
person = dict.fromkeys(keys)  # 所有键的默认值为None
print(person)  # 输出：{'name': None, 'age': None, 'gender': None}

# 指定默认值
person2 = dict.fromkeys(keys, "未知")
print(person2)  # 输出：{'name': '未知', 'age': '未知', 'gender': '未知'}

解析：dict.fromkeys(iterable, value)用可迭代对象的元素作为键，value作为默认值创建新字典。

17. 题目：遍历字典的键

需求：遍历字典{"name": "张三", "age": 18}的所有键并打印。

person = {"name": "张三", "age": 18}
for key in person:  # 等价于 for key in person.keys()
    print(key)
# 输出：
# name
# age

解析：直接遍历字典等价于遍历其键，也可通过person.keys()显式遍历。

18. 题目：遍历字典的值

需求：遍历字典{"math": 90, "english": 85}的所有值并打印。

scores = {"math": 90, "english": 85}
for value in scores.values():
    print(value)
# 输出：
# 90
# 85

解析：scores.values()返回值视图，可直接遍历所有值。

19. 题目：遍历字典的键值对

需求：遍历字典{"a": 1, "b": 2}的所有键值对并打印。

my_dict = {"a": 1, "b": 2}
for key, value in my_dict.items():  # items()返回键值对视图
    print(f"{key}: {value}")
# 输出：
# a: 1
# b: 2

解析：dict.items()返回包含键值对元组的视图，通过for key, value可同时获取键和值。

20. 题目：获取字典的长度

需求：计算字典{"name": "李四", "age": 20, "job": "工程师"}中键值对的数量。

person = {"name": "李四", "age": 20, "job": "工程师"}
print(len(person))  # 输出：3

解析：len()函数返回字典中键值对的数量，即字典的长度。

21. 题目：字典中值的累加

需求：向字典{"苹果": 2, "香蕉": 3}中，将"苹果"的数量增加1。

fruits = {"苹果": 2, "香蕉": 3}
fruits["苹果"] += 1  # 累加值
print(fruits)  # 输出：{'苹果': 3, '香蕉': 3}

解析：通过字典名[key] += 增量可实现值的累加，适用于数值类型的值。

22. 题目：合并两个字典（不修改原字典）

需求：将{"a": 1}和{"b": 2}合并为新字典{"a": 1, "b": 2}，原字典不变。

dict1 = {"a": 1}
dict2 = {"b": 2}
# 方法1：字典解包（Python 3.5+）
merged = {** dict1, **dict2}
# 方法2：创建新字典并更新
# merged = dict1.copy()
# merged.update(dict2)
print(merged)    # 输出：{'a': 1, 'b': 2}
print(dict1)     # 输出：{'a': 1}（原字典不变）

解析：方法1用**解包两个字典并合并为新字典，方法2通过拷贝+更新实现，均不修改原字典。

23. 题目：处理字典中不存在的键（设置默认值）

需求：获取字典{"a": 1}中"b"的值，若不存在则设置为0并返回。

my_dict = {"a": 1}
# 方法1：使用get()后判断
value = my_dict.get("b", 0)
if "b" not in my_dict:
    my_dict["b"] = value
# 方法2：使用setdefault()（更简洁）
value = my_dict.setdefault("b", 0)

print(my_dict)  # 输出：{'a': 1, 'b': 0}
print(value)    # 输出：0

解析：dict.setdefault(key, default)若键不存在，则设置key: default并返回default，否则返回现有值，是设置默认值的便捷方法。

24. 题目：字典中最大的值

需求：找出字典{"a": 10, "b": 20, "c": 5}中值最大的键值对。

my_dict = {"a": 10, "b": 20, "c": 5}
max_value = max(my_dict.values())  # 最大值
# 找出所有值为最大值的键（可能多个）
max_items = [(k, v) for k, v in my_dict.items() if v == max_value]
print(max_items)  # 输出：[('b', 20)]

解析：先通过max()找到最大值，再筛选出所有值等于最大值的键值对（支持多个相同最大值）。

25. 题目：字典中最小的值

需求：找出字典{"x": 5, "y": 2, "z": 8}中值最小的键。

coords = {"x": 5, "y": 2, "z": 8}
# 按值排序，取第一个的键
min_key = min(coords, key=coords.get)
print(min_key)  # 输出：y

解析：min(dict, key=dict.get)返回值最小的键，key=dict.get指定按值比较。

26. 题目：字典值的求和

需求：计算字典{"语文": 80, "数学": 90, "英语": 85}中所有值的总和。

scores = {"语文": 80, "数学": 90, "英语": 85}
total = sum(scores.values())
print(total)  # 输出：255

解析：sum()函数可直接对dict.values()返回的可迭代对象求和，前提是值为数值类型。

27. 题目：字典按键排序

需求：将字典{"b": 2, "a": 1, "c": 3}按键升序排列，返回包含键值对的列表。

my_dict = {"b": 2, "a": 1, "c": 3}
# 按键排序，返回列表
sorted_by_key = sorted(my_dict.items(), key=lambda x: x[0])
print(sorted_by_key)  # 输出：[('a', 1), ('b', 2), ('c', 3)]

解析：sorted(dict.items(), key=lambda x: x[0])按键（元组第一个元素）排序，返回排序后的列表。

28. 题目：字典按值排序

需求：将字典{"b": 2, "a": 1, "c": 3}按值降序排列，返回新字典。

my_dict = {"b": 2, "a": 1, "c": 3}
# 按值降序排序，转换为OrderedDict（Python 3.7+普通字典也保留顺序）
sorted_items = sorted(my_dict.items(), key=lambda x: x[1], reverse=True)
sorted_dict = dict(sorted_items)
print(sorted_dict)  # 输出：{'c': 3, 'b': 2, 'a': 1}

解析：先按值（元组第二个元素）降序排序，再用dict()转换为字典（Python 3.7+保留排序顺序）。

29. 题目：过滤字典中值大于10的键值对

需求：从{"a": 5, "b": 15, "c": 12, "d": 8}中筛选出值大于10的键值对。

my_dict = {"a": 5, "b": 15, "c": 12, "d": 8}
filtered = {k: v for k, v in my_dict.items() if v > 10}
print(filtered)  # 输出：{'b': 15, 'c': 12}

解析：字典推导式筛选出值满足条件的键值对，生成新字典。

30. 题目：字典中值的去重

需求：从{"a": 1, "b": 2, "c": 1, "d": 3, "e": 2}中去除值重复的键值对（保留首次出现的键）。

my_dict = {"a": 1, "b": 2, "c": 1, "d": 3, "e": 2}
seen = set()
unique_dict = {}
for k, v in my_dict.items():
    if v not in seen:
        seen.add(v)
        unique_dict[k] = v
print(unique_dict)  # 输出：{'a': 1, 'b': 2, 'd': 3}

解析：用集合记录已出现的值，遍历字典时只保留值首次出现的键值对，实现值的去重。

三、字典推导式（31-45）

31. 题目：用字典推导式创建字典

需求：创建键为1-5，值为键的平方的字典{1:1, 2:4, ..., 5:25}。

squares = {i: i** 2 for i in range(1, 6)}
print(squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

解析：字典推导式{key_expr: value_expr for item in iterable}是创建字典的简洁方式，等价于循环+赋值。

32. 题目：用列表对创建字典

需求：将键列表["name", "age"]和值列表["张三", 18]转换为字典。

keys = ["name", "age"]
values = ["张三", 18]
person = {k: v for k, v in zip(keys, values)}
print(person)  # 输出：{'name': '张三', 'age': 18}

解析：zip(keys, values)将两个列表配对为元组，再通过字典推导式转换为字典（键值对数量以短列表为准）。

33. 题目：带条件的字典推导式（筛选键）

需求：从{"a": 1, "b": 2, "c": 3, "d": 4}中筛选出键为小写字母且在["a", "c"]中的键值对。

my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
filtered = {k: v for k, v in my_dict.items() if k in ["a", "c"]}
print(filtered)  # 输出：{'a': 1, 'c': 3}

解析：通过if条件筛选键，只保留符合条件的键值对。

34. 题目：带条件的字典推导式（修改值）

需求：将{"a": 5, "b": 15, "c": 25}中值大于10的改为"大"，否则改为"小"。

my_dict = {"a": 5, "b": 15, "c": 25}
result = {k: "大" if v > 10 else "小" for k, v in my_dict.items()}
print(result)  # 输出：{'a': '小', 'b': '大', 'c': '大'}

解析：值表达式用三目运算符"大" if v > 10 else "小"，根据条件生成不同值。

35. 题目：字典推导式实现键值互换

需求：将字典{"a": 1, "b": 2}转换为{1: "a", 2: "b"}（假设值唯一）。

original = {"a": 1, "b": 2}
swapped = {v: k for k, v in original.items()}
print(swapped)  # 输出：{1: 'a', 2: 'b'}

解析：键值互换要求原字典的值唯一，否则会有键被覆盖（保留最后一个）。

36. 题目：用字典推导式处理字符串列表

需求：将列表["apple", "banana", "cherry"]转换为{"apple": 5, "banana": 6, "cherry": 6}（值为字符串长度）。

fruits = ["apple", "banana", "cherry"]
fruit_lengths = {fruit: len(fruit) for fruit in fruits}
print(fruit_lengths)  # 输出：{'apple': 5, 'banana': 6, 'cherry': 6}

解析：以列表元素为键，元素长度为值，通过字典推导式快速生成。

37. 题目：嵌套字典推导式

需求：创建一个2x2的矩阵字典{0: {0: 0, 1: 1}, 1: {0: 1, 1: 2}}。

matrix = {i: {j: i + j for j in range(2)} for i in range(2)}
print(matrix)  # 输出：{0: {0: 0, 1: 1}, 1: {0: 1, 1: 2}}

解析：嵌套字典推导式，外层生成行键，内层生成列键和值，适合创建多维结构。

38. 题目：用字典推导式过滤空值

需求：从{"name": "张三", "age": None, "gender": "男", "address": ""}中过滤掉值为None或空字符串的键值对。

person = {"name": "张三", "age": None, "gender": "男", "address": ""}
filtered = {k: v for k, v in person.items() if v not in (None, "")}
print(filtered)  # 输出：{'name': '张三', 'gender': '男'}

解析：通过if v not in (None, "")筛选出非空值的键值对。

39. 题目：字典推导式实现计数器

需求：统计列表["a", "b", "a", "c", "a", "b"]中元素出现的次数，生成{"a": 3, "b": 2, "c": 1}。

lst = ["a", "b", "a", "c", "a", "b"]
counter = {item: lst.count(item) for item in set(lst)}
print(counter)  # 输出：{'a': 3, 'b': 2, 'c': 1}（顺序可能不同）

解析：先用set(lst)去重获取唯一元素，再用lst.count(item)统计次数，实现简单计数。

40. 题目：字典推导式转换键名

需求：将字典{"name": "张三", "age": 18}的键名转为大写，得到{"NAME": "张三", "AGE": 18}。

person = {"name": "张三", "age": 18}
upper_keys = {k.upper(): v for k, v in person.items()}
print(upper_keys)  # 输出：{'NAME': '张三', 'AGE': 18}

解析：键表达式k.upper()将键名转为大写，生成新字典。

41. 题目：字典推导式处理数值范围

需求：创建键为1-10的偶数，值为键的一半的字典{2:1, 4:2, ..., 10:5}。

even_half = {i: i // 2 for i in range(1, 11) if i % 2 == 0}
print(even_half)  # 输出：{2: 1, 4: 2, 6: 3, 8: 4, 10: 5}

解析：先筛选出偶数键，再计算值为键的一半，结合条件和表达式。

42. 题目：用字典推导式合并多个字典

需求：将{"a": 1}、{"b": 2}、{"c": 3}合并为一个字典（相同键取最后一个）。

dict1 = {"a": 1}
dict2 = {"b": 2}
dict3 = {"c": 3}
merged = {k: v for d in [dict1, dict2, dict3] for k, v in d.items()}
print(merged)  # 输出：{'a': 1, 'b': 2, 'c': 3}

解析：双层循环，外层遍历字典列表，内层遍历每个字典的键值对，实现合并。

43. 题目：字典推导式筛选并转换值

需求：从{"a": "1", "b": "2", "c": "三"}中筛选出值为数字字符串的键，并将值转为整数。

my_dict = {"a": "1", "b": "2", "c": "三"}
result = {k: int(v) for k, v in my_dict.items() if v.isdigit()}
print(result)  # 输出：{'a': 1, 'b': 2}

解析：if v.isdigit()筛选数字字符串，int(v)将值转为整数，实现筛选+转换。

44. 题目：字典推导式生成字母表

需求：生成键为字母"a"-“e”，值为对应ASCII码的字典{"a": 97, "b": 98, ..., "e": 101}。

import string
# string.ascii_lowercase 包含'a'-'z'
letter_ascii = {c: ord(c) for c in string.ascii_lowercase[:5]}
print(letter_ascii)  # 输出：{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101}

解析：string.ascii_lowercase提供小写字母序列，ord(c)获取ASCII码，快速生成映射字典。

45. 题目：字典推导式处理嵌套列表

需求：将[("name", "张三"), ("age", 18), ("gender", "男")]转换为字典。

pairs = [("name", "张三"), ("age", 18), ("gender", "男")]
person = {k: v for k, v in pairs}
print(person)  # 输出：{'name': '张三', 'age': 18, 'gender': '男'}

解析：遍历包含键值对元组的列表，直接用推导式转换为字典，比dict(pairs)更灵活（可加条件）。

四、嵌套字典（46-65）

46. 题目：创建嵌套字典

需求：创建包含学生信息的嵌套字典，如{"张三": {"math": 90, "english": 85}, "李四": {"math": 88, "english": 92}}。

students = {
    "张三": {
        "math": 90,
        "english": 85
    },
    "李四": {
        "math": 88,
        "english": 92
    }
}
print(students)
# 输出：{'张三': {'math': 90, 'english': 85}, '李四': {'math': 88, 'english': 92}}

解析：嵌套字典是值为字典的字典，可用于表示多层级数据（如学生→科目→成绩）。

47. 题目：访问嵌套字典中的值

需求：从嵌套字典{"张三": {"math": 90}, "李四": {"math": 88}}中获取"张三"的数学成绩。

students = {"张三": {"math": 90}, "李四": {"math": 88}}
# 逐层访问：先访问外层键"张三"，再访问内层键"math"
score = students["张三"]["math"]
print(score)  # 输出：90

解析：dict[outer_key][inner_key]可访问嵌套字典中的内层值，需确保每层键都存在，否则会抛KeyError。

48. 题目：修改嵌套字典中的值

需求：将嵌套字典{"a": {"x": 10}, "b": {"y": 20}}中"a"的"x"值改为100。

nested = {"a": {"x": 10}, "b": {"y": 20}}
nested["a"]["x"] = 100  # 逐层修改
print(nested)  # 输出：{'a': {'x': 100}, 'b': {'y': 20}}

解析：通过多层键访问到目标值后，直接赋值修改。

49. 题目：向嵌套字典中添加键值对

需求：向{"张三": {"math": 90}}中为"张三"添加英语成绩85。

students = {"张三": {"math": 90}}
students["张三"]["english"] = 85  # 向内层字典添加键值对
print(students)  # 输出：{'张三': {'math': 90, 'english': 85}}

解析：先访问外层键获取内层字典，再为内层字典添加新键值对。

50. 题目：删除嵌套字典中的键值对

需求：从{"a": {"x": 1, "y": 2}, "b": {"z": 3}}中删除"a"的"y"键。

nested = {"a": {"x": 1, "y": 2}, "b": {"z": 3}}
del nested["a"]["y"]  # 删除内层键值对
print(nested)  # 输出：{'a': {'x': 1}, 'b': {'z': 3}}

解析：用del语句逐层删除嵌套字典中的键值对。

51. 题目：遍历嵌套字典

需求：遍历嵌套字典{"张三": {"math": 90, "english": 85}, "李四": {"math": 88}}，打印每个学生的科目和成绩。

students = {
    "张三": {"math": 90, "english": 85},
    "李四": {"math": 88}
}
for name, scores in students.items():
    print(f"{name}的成绩：")
    for subject, score in scores.items():
        print(f"  {subject}: {score}")
# 输出：
# 张三的成绩：
#   math: 90
#   english: 85
# 李四的成绩：
#   math: 88

解析：通过嵌套循环遍历，外层获取学生名和成绩字典，内层遍历成绩字典的科目和分数。

52. 题目：计算嵌套字典中值的总和

需求：计算{"A班": {"张三": 90, "李四": 85}, "B班": {"王五": 92}}中所有学生的总分。

classes = {
    "A班": {"张三": 90, "李四": 85},
    "B班": {"王五": 92}
}
total = 0
for class_scores in classes.values():
    total += sum(class_scores.values())  # 累加每个班的总分
print(total)  # 输出：267

解析：外层循环遍历每个班级的成绩字典，内层用sum()计算每个班的总分，累加得到总分数。

53. 题目：查找嵌套字典中的最大值

需求：找出{"A": {"x": 10, "y": 20}, "B": {"z": 15}}中所有值的最大值。

nested = {"A": {"x": 10, "y": 20}, "B": {"z": 15}}
max_value = None
for inner_dict in nested.values():
    current_max = max(inner_dict.values())
    if max_value is None or current_max > max_value:
        max_value = current_max
print(max_value)  # 输出：20

解析：遍历每个内层字典，计算其最大值，再与当前全局最大值比较，更新全局最大值。

54. 题目：筛选嵌套字典中符合条件的元素

需求：从{"张三": {"math": 90, "english": 85}, "李四": {"math": 75, "english": 60}}中筛选出数学成绩≥80的学生。

students = {
    "张三": {"math": 90, "english": 85},
    "李四": {"math": 75, "english": 60}
}
filtered = {
    name: scores for name, scores in students.items()
    if scores.get("math", 0) >= 80
}
print(filtered)  # 输出：{'张三': {'math': 90, 'english': 85}}

解析：字典推导式外层筛选学生，条件为数学成绩≥80（用get()避免键不存在）。

55. 题目：嵌套字典的深拷贝

需求：深拷贝嵌套字典{"a": {"x": 1}, "b": 2}，修改拷贝的内层值不影响原字典。

import copy

original = {"a": {"x": 1}, "b": 2}
# 深拷贝（递归拷贝所有层级）
deep_copy = copy.deepcopy(original)
deep_copy["a"]["x"] = 99  # 修改拷贝的内层值

print(original)    # 输出：{'a': {'x': 1}, 'b': 2}（原字典不变）
print(deep_copy)   # 输出：{'a': {'x': 99}, 'b': 2}

解析：普通copy()是浅拷贝（仅拷贝外层，内层仍为引用），copy.deepcopy()会递归拷贝所有层级，适合嵌套字典。

56. 题目：将嵌套字典扁平化

需求：将{"a": {"x": 1, "y": 2}, "b": {"z": 3}}扁平化为{"a.x": 1, "a.y": 2, "b.z": 3}。

def flatten_dict(nested, parent_key="", sep="."):
    items = []
    for k, v in nested.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            # 递归处理嵌套字典
            items.extend(flatten_dict(v, new_key, sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

nested = {"a": {"x": 1, "y": 2}, "b": {"z": 3}}
flattened = flatten_dict(nested)
print(flattened)  # 输出：{'a.x': 1, 'a.y': 2, 'b.z': 3}

解析：通过递归遍历嵌套字典，将多层键用分隔符拼接为扁平键，适合需要单层结构的场景。

57. 题目：嵌套字典中按条件删除元素

需求：从{"A": {"x": 5, "y": 15}, "B": {"z": 8}}中删除所有值小于10的内层键值对。

nested = {"A": {"x": 5, "y": 15}, "B": {"z": 8}}
for inner_dict in nested.values():
    # 找出值小于10的键（需先转为列表避免迭代中修改）
    to_delete = [k for k, v in inner_dict.items() if v < 10]
    for k in to_delete:
        del inner_dict[k]

print(nested)  # 输出：{'A': {'y': 15}, 'B': {}}

解析：先收集需要删除的键（避免迭代中修改字典导致错误），再批量删除，确保安全。

58. 题目：嵌套字典中统计符合条件的元素个数

需求：统计{"class1": {"张三": 90, "李四": 85}, "class2": {"王五": 70}}中成绩≥80的学生人数。

classes = {
    "class1": {"张三": 90, "李四": 85},
    "class2": {"王五": 70}
}
count = 0
for scores in classes.values():
    # 统计每个班级中成绩≥80的人数
    count += sum(1 for score in scores.values() if score >= 80)
print(count)  # 输出：2

解析：内层用生成器表达式统计每个班级的合格人数，外层累加得到总人数。

59. 题目：嵌套字典的键存在性检查

需求：检查嵌套字典{"a": {"x": 1}}中是否存在键路径"a.x"（即"a"存在且其下"x"存在）。

def has_nested_key(nested, keys):
    """检查嵌套字典中是否存在键路径（keys为键列表，如["a", "x"]）"""
    current = nested
    for key in keys:
        if not isinstance(current, dict) or key not in current:
            return False
        current = current[key]
    return True

nested = {"a": {"x": 1}}
print(has_nested_key(nested, ["a", "x"]))  # 输出：True
print(has_nested_key(nested, ["a", "y"]))  # 输出：False

解析：通过循环逐层检查键是否存在，若任何一层不存在则返回False，适合验证多层级键。

60. 题目：更新嵌套字典中的值

需求：将{"a": {"x": 10}, "b": 20}中所有数值加5，得到{"a": {"x": 15}, "b": 25}。

def update_nested(nested, func):
    """递归更新嵌套字典中的值，func为处理函数"""
    for k, v in nested.items():
        if isinstance(v, dict):
            update_nested(v, func)  # 递归处理内层字典
        else:
            nested[k] = func(v)

nested = {"a": {"x": 10}, "b": 20}
update_nested(nested, lambda x: x + 5)  # 所有值加5
print(nested)  # 输出：{'a': {'x': 15}, 'b': 25}

解析：递归遍历嵌套字典，对非字典值应用处理函数（此处为加5），实现批量更新。

61. 题目：创建三级嵌套字典

需求：创建表示"学校→年级→班级→人数"的三级嵌套字典。

school = {
    "高一": {
        "一班": 45,
        "二班": 48
    },
    "高二": {
        "一班": 42,
        "二班": 46
    }
}
print(school["高一"]["一班"])  # 输出：45（访问三级值）

解析：三级嵌套字典可表示更复杂的层级关系，访问时需逐层指定键。

62. 题目：从嵌套字典中提取特定键的值

需求：从{"张三": {"math": 90, "english": 85}, "李四": {"math": 88, "english": 92}}中提取所有学生的英语成绩，生成{"张三": 85, "李四": 92}。

students = {
    "张三": {"math": 90, "english": 85},
    "李四": {"math": 88, "english": 92}
}
english_scores = {
    name: scores["english"] for name, scores in students.items()
    if "english" in scores  # 确保键存在
}
print(english_scores)  # 输出：{'张三': 85, '李四': 92}

解析：字典推导式筛选每个学生的"english"键对应的值，生成新字典。

63. 题目：嵌套字典中按值排序

需求：将{"A": {"score": 80}, "B": {"score": 90}, "C": {"score": 70}}按"score"值降序排序。

nested = {"A": {"score": 80}, "B": {"score": 90}, "C": {"score": 70}}
# 按内层"score"值降序排序
sorted_items = sorted(nested.items(), key=lambda x: x[1]["score"], reverse=True)
sorted_dict = dict(sorted_items)
print(sorted_dict)  # 输出：{'B': {'score': 90}, 'A': {'score': 80}, 'C': {'score': 70}}

解析：key=lambda x: x[1]["score"]指定按内层字典的"score"值排序，再转换为字典。

64. 题目：合并两个嵌套字典

需求：合并{"a": {"x": 1}, "b": 2}和{"a": {"y": 3}, "c": 4}，相同外层键的内层字典合并。

def merge_nested(d1, d2):
    """合并两个嵌套字典，内层字典递归合并"""
    merged = d1.copy()
    for k, v in d2.items():
        if k in merged and isinstance(merged[k], dict) and isinstance(v, dict):
            # 递归合并内层字典
            merged[k] = merge_nested(merged[k], v)
        else:
            merged[k] = v
    return merged

d1 = {"a": {"x": 1}, "b": 2}
d2 = {"a": {"y": 3}, "c": 4}
merged = merge_nested(d1, d2)
print(merged)  # 输出：{'a': {'x': 1, 'y': 3}, 'b': 2, 'c': 4}

解析：递归合并字典，若外层键相同且均为字典，则合并内层，否则用d2的值覆盖d1。

65. 题目：嵌套字典的键路径列表

需求：获取{"a": {"x": 1, "y": 2}, "b": 3}中所有值的键路径，如[("a", "x"), ("a", "y"), ("b",)]。

def get_key_paths(nested):
    paths = []
    def traverse(current, path):
        if isinstance(current, dict):
            for k, v in current.items():
                traverse(v, path + (k,))  # 递归时扩展路径
        else:
            paths.append(path)
    traverse(nested, ())
    return paths

nested = {"a": {"x": 1, "y": 2}, "b": 3}
print(get_key_paths(nested))  # 输出：[('a', 'x'), ('a', 'y'), ('b',)]

解析：通过递归遍历，收集所有值对应的键路径（元组形式），便于索引嵌套字典中的值。

五、字典与其他数据结构转换（66-80）

66. 题目：将列表转换为字典（以索引为键）

需求：将列表["a", "b", "c"]转换为{0: "a", 1: "b", 2: "c"}。

lst = ["a", "b", "c"]
my_dict = {i: v for i, v in enumerate(lst)}
print(my_dict)  # 输出：{0: 'a', 1: 'b', 2: 'c'}

解析：enumerate(lst)返回(索引, 值)元组，通过字典推导式转换为字典。

67. 题目：将两个列表转换为字典（一一对应）

需求：将键列表["name", "age"]和值列表["张三", 18]转换为字典。

keys = ["name", "age"]
values = ["张三", 18]
person = dict(zip(keys, values))  # zip()配对后转换
print(person)  # 输出：{'name': '张三', 'age': 18}

解析：zip(keys, values)将两个列表的元素一一配对为元组，dict()直接转换为字典。

68. 题目：将字典转换为列表（键值对元组）

需求：将字典{"a": 1, "b": 2}转换为[('a', 1), ('b', 2)]。

my_dict = {"a": 1, "b": 2}
items_list = list(my_dict.items())
print(items_list)  # 输出：[('a', 1), ('b', 2)]

解析：dict.items()返回键值对视图，用list()转换为包含元组的列表。

69. 题目：将字典的键转换为列表

需求：将{"name": "张三", "age": 18}的键转换为["name", "age"]。

person = {"name": "张三", "age": 18}
keys_list = list(person.keys())
print(keys_list)  # 输出：['name', 'age']

解析：dict.keys()返回键视图，转换为列表后包含所有键（Python 3.7+保留顺序）。

70. 题目：将字典的值转换为列表

需求：将{"math": 90, "english": 85}的值转换为[90, 85]。

scores = {"math": 90, "english": 85}
values_list = list(scores.values())
print(values_list)  # 输出：[90, 85]

解析：dict.values()返回值视图，转换为列表后包含所有值。

71. 题目：将字典转换为JSON字符串

需求：将字典{"name": "张三", "age": 18}转换为JSON字符串。

import json

person = {"name": "张三", "age": 18}
json_str = json.dumps(person, ensure_ascii=False)  # ensure_ascii=False保留中文
print(json_str)  # 输出：{"name": "张三", "age": 18}

解析：json.dumps()将字典转换为JSON字符串，ensure_ascii=False确保中文正常显示（否则会转为Unicode编码）。

72. 题目：将JSON字符串转换为字典

需求：将JSON字符串'{"name": "张三", "age": 18}'转换为字典。

import json

json_str = '{"name": "张三", "age": 18}'
person = json.loads(json_str)
print(person)  # 输出：{'name': '张三', 'age': 18}
print(type(person))  # 输出：<class 'dict'>

解析：json.loads()将JSON字符串解析为字典，是处理JSON数据的常用操作。

73. 题目：将字典转换为集合（键的集合）

需求：将字典{"a": 1, "b": 2}的键转换为集合{"a", "b"}。

my_dict = {"a": 1, "b": 2}
key_set = set(my_dict.keys())
# 或直接 set(my_dict)（字典转换为集合默认取键）
print(key_set)  # 输出：{'a', 'b'}

解析：字典直接转换为集合（set(my_dict)）等价于转换键的集合，与set(my_dict.keys())效果相同。

74. 题目：将字典转换为元组（键值对元组）

需求：将字典{"a": 1, "b": 2}转换为元组(('a', 1), ('b', 2))。

my_dict = {"a": 1, "b": 2}
items_tuple = tuple(my_dict.items())
print(items_tuple)  # 输出：(('a', 1), ('b', 2))

解析：tuple(my_dict.items())将键值对视图转换为元组，元组元素为键值对元组。

75. 题目：将列表中的字典按指定键排序

需求：将[ {"name": "张三", "age": 18}, {"name": "李四", "age": 20} ]按"age"升序排序。

people = [
    {"name": "张三", "age": 18},
    {"name": "李四", "age": 20}
]
# 按"age"键排序
people_sorted = sorted(people, key=lambda x: x["age"])
print(people_sorted)
# 输出：[{'name': '张三', 'age': 18}, {'name': '李四', 'age': 20}]

解析：sorted()的key参数指定按字典的"age"键值排序，适用于列表中包含多个字典的场景。

76. 题目：将两个长度相同的列表转为字典并交换键值

需求：将["a", "b"]和[1, 2]转为{1: "a", 2: "b"}。

keys = ["a", "b"]
values = [1, 2]
original = dict(zip(keys, values))  # 先转为{"a":1, "b":2}
swapped = {v: k for k, v in original.items()}  # 键值互换
print(swapped)  # 输出：{1: 'a', 2: 'b'}

解析：先将列表转为普通字典，再通过字典推导式互换键值，适用于值唯一的情况。

77. 题目：将字典转换为查询字符串

需求：将{"name": "张三", "age": 18}转换为"name=张三&age=18"。

def dict_to_query(d):
    return "&".join([f"{k}={v}" for k, v in d.items()])

params = {"name": "张三", "age": 18}
query_str = dict_to_query(params)
print(query_str)  # 输出：name=张三&age=18

解析：通过列表推导式生成"键=值"字符串，再用&连接，常用于构建URL查询参数。

78. 题目：将查询字符串转换为字典

需求：将"name=张三&age=18"转换为{"name": "张三", "age": "18"}。

def query_to_dict(query_str):
    items = query_str.split("&")
    return {k: v for item in items for k, v in [item.split("=")]}

query_str = "name=张三&age=18"
params = query_to_dict(query_str)
print(params)  # 输出：{'name': '张三', 'age': '18'}

解析：先按&分割查询字符串，再按=分割每个键值对，通过字典推导式转换为字典。

79. 题目：将嵌套列表转换为嵌套字典

需求：将[("a", [("x", 1), ("y", 2)]), ("b", 3)]转换为{"a": {"x": 1, "y": 2}, "b": 3}。

nested_list = [("a", [("x", 1), ("y", 2)]), ("b", 3)]
nested_dict = {}
for k, v in nested_list:
    if isinstance(v, list) and all(isinstance(i, tuple) for i in v):
        # 若值是包含元组的列表，则转换为字典
        nested_dict[k] = dict(v)
    else:
        nested_dict[k] = v

print(nested_dict)  # 输出：{'a': {'x': 1, 'y': 2}, 'b': 3}

解析：遍历列表中的键值对，若值是包含元组的列表，则递归转换为字典，否则直接赋值。

80. 题目：将字典转换为类对象

需求：将字典{"name": "张三", "age": 18}转换为类对象，通过obj.name访问属性。

class DictToObj:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)  # 将字典键值对转为对象属性

person_dict = {"name": "张三", "age": 18}
person_obj = DictToObj(** person_dict)
print(person_obj.name)  # 输出：张三
print(person_obj.age)   # 输出：18

解析：通过__dict__.update(kwargs)将字典键值对动态添加为对象属性，实现字典到对象的转换。

六、字典综合应用（81-100）

81. 题目：统计字符串中字符出现的频率

需求：统计"abracadabra"中每个字符出现的频率，生成{'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}。

s = "abracadabra"
frequency = {}
for char in s:
    frequency[char] = frequency.get(char, 0) + 1
print(frequency)  # 输出：{'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

解析：遍历字符串的每个字符，用字典记录出现次数，get()方法确保初始值为0。

82. 题目：实现简易通讯录（字典存储）

需求：用字典实现通讯录，支持添加、查询联系人，如{"张三": "123456", "李四": "789012"}。

contacts = {}

def add_contact(name, phone):
    contacts[name] = phone
    print(f"添加成功：{name} - {phone}")

def find_contact(name):
    return contacts.get(name, f"未找到{name}的联系方式")

# 测试
add_contact("张三", "123456")
add_contact("李四", "789012")
print(find_contact("张三"))  # 输出：123456
print(find_contact("王五"))  # 输出：未找到王五的联系方式

解析：字典的键作为联系人姓名，值作为电话号码，通过函数封装添加和查询功能。

83. 题目：合并多个字典，相同键的值求和

需求：合并{"a": 1, "b": 2}、{"b": 3, "c": 4}，相同键的值求和，结果{"a":1, "b":5, "c":4}。

def merge_and_sum(*dicts):
    result = {}
    for d in dicts:
        for k, v in d.items():
            result[k] = result.get(k, 0) + v
    return result

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = merge_and_sum(d1, d2)
print(merged)  # 输出：{'a': 1, 'b': 5, 'c': 4}

解析：遍历所有字典，对相同键的值累加，适用于需要合并统计的场景（如销售数据）。

84. 题目：按值对字典分组

需求：将{"a": 1, "b": 2, "c": 1, "d": 3}按值分组，得到{1: ["a", "c"], 2: ["b"], 3: ["d"]}。

my_dict = {"a": 1, "b": 2, "c": 1, "d": 3}
grouped = {}
for k, v in my_dict.items():
    if v not in grouped:
        grouped[v] = []
    grouped[v].append(k)  # 将键添加到对应值的列表中
print(grouped)  # 输出：{1: ['a', 'c'], 2: ['b'], 3: ['d']}

解析：以值为键创建新字典，值为包含原字典对应键的列表，实现按值分组。

85. 题目：过滤字典中值为None的键值对

需求：从{"name": "张三", "age": None, "gender": "男"}中去除值为None的键值对。

person = {"name": "张三", "age": None, "gender": "男"}
filtered = {k: v for k, v in person.items() if v is not None}
print(filtered)  # 输出：{'name': '张三', 'gender': '男'}

解析：字典推导式筛选出值不为None的键值对，常用于清理无效数据。

86. 题目：实现两个列表的交集（用字典）

需求：找出[1, 2, 3, 4]和[3, 4, 5, 6]的交集，用字典实现（效率高于列表）。

def intersect(list1, list2):
    # 将第一个列表转为值为True的字典（模拟集合）
    set1 = {x: True for x in list1}
    # 筛选第二个列表中存在于第一个列表的元素
    return [x for x in list2 if x in set1]

print(intersect([1, 2, 3, 4], [3, 4, 5, 6]))  # 输出：[3, 4]

解析：利用字典的in操作效率高于列表（O(1) vs O(n)），先将列表转为字典，再筛选交集。

87. 题目：计算字典中值的平均值

需求：计算{"math": 90, "english": 85, "chinese": 95}中成绩的平均值。

scores = {"math": 90, "english": 85, "chinese": 95}
average = sum(scores.values()) / len(scores)
print(average)  # 输出：90.0

解析：总和除以键值对数量得到平均值，需确保字典非空（避免除零错误）。

88. 题目：将字典中的键值对按条件互换

需求：将{"a": 1, "b": "2", "c": 3}中值为整数的键值互换，得到{1: "a", "2": "b", 3: "c"}。

my_dict = {"a": 1, "b": "2", "c": 3}
swapped = {}
for k, v in my_dict.items():
    # 无论值类型，均互换（若值不可哈希会报错，此处假设值可哈希）
    swapped[v] = k
print(swapped)  # 输出：{1: 'a', '2': 'b', 3: 'c'}

解析：遍历字典，将值作为新键，键作为新值，需确保原字典的值可哈希（否则不能作为键）。

89. 题目：查找字典中值的中位数

需求：找出{"a": 3, "b": 1, "c": 2, "d": 4}中值的中位数（排序后中间值，偶数个取平均）。

my_dict = {"a": 3, "b": 1, "c": 2, "d": 4}
values = sorted(my_dict.values())  # 排序值
n = len(values)
if n % 2 == 1:
    median = values[n // 2]
else:
    median = (values[n//2 - 1] + values[n//2]) / 2
print(median)  # 输出：2.5（(2+3)/2）

解析：先排序值列表，根据长度奇偶计算中位数，适用于数值型值的统计。

90. 题目：用字典实现简易计数器

需求：实现一个计数器，支持add(key)（计数+1）和get(key)（获取计数）。

class Counter:
    def __init__(self):
        self.counts = {}
    
    def add(self, key):
        self.counts[key] = self.counts.get(key, 0) + 1
    
    def get(self, key):
        return self.counts.get(key, 0)

# 测试
counter = Counter()
counter.add("a")
counter.add("a")
counter.add("b")
print(counter.get("a"))  # 输出：2
print(counter.get("b"))  # 输出：1
print(counter.get("c"))  # 输出：0

解析：用字典存储计数，add()方法递增计数，get()方法获取计数（默认0），模拟collections.Counter的核心功能。

91. 题目：字典中值的标准差计算

需求：计算{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}中值的标准差。

import math

my_dict = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
values = list(my_dict.values())
mean = sum(values) / len(values)  # 平均值
# 方差 = 每个值与平均值差的平方的平均值
variance = sum((x - mean) **2 for x in values) / len(values)
std_dev = math.sqrt(variance)  # 标准差
print(std_dev)  # 输出：1.4142135623730951

解析：标准差是方差的平方根，反映数据的离散程度，通过字典值列表计算。

92. 题目：按条件过滤嵌套字典

需求：从{"class1": {"张三": 90, "李四": 60}, "class2": {"王五": 85}}中筛选出成绩≥80的学生，保留班级结构。

classes = {
    "class1": {"张三": 90, "李四": 60},
    "class2": {"王五": 85}
}
filtered = {}
for class_name, students in classes.items():
    # 筛选每个班级中成绩≥80的学生
    passed = {name: score for name, score in students.items() if score >= 80}
    if passed:  # 只保留有合格学生的班级
        filtered[class_name] = passed

print(filtered)  # 输出：{'class1': {'张三': 90}, 'class2': {'王五': 85}}

解析：外层遍历班级，内层筛选合格学生，只保留有合格学生的班级，保持嵌套结构。

93. 题目：字典中最常见的值

需求：找出{"a": 1, "b": 2, "c": 1, "d": 3, "e": 1}中出现次数最多的值。

my_dict = {"a": 1, "b": 2, "c": 1, "d": 3, "e": 1}
# 先统计值的出现频率
value_counts = {}
for v in my_dict.values():
    value_counts[v] = value_counts.get(v, 0) + 1
# 找出频率最高的值
most_common_value = max(value_counts, key=value_counts.get)
print(most_common_value)  # 输出：1

解析：先统计每个值的出现次数，再找出频率最高的值，适用于需要分析值分布的场景。

94. 题目：将字典中的键按值排序并取前N个

需求：从{"a": 10, "b": 5, "c": 15, "d": 8}中按值降序取前2个键，得到["c", "a"]。

my_dict = {"a": 10, "b": 5, "c": 15, "d": 8}
# 按值降序排序键
sorted_keys = sorted(my_dict, key=my_dict.get, reverse=True)
# 取前2个
top2 = sorted_keys[:2]
print(top2)  # 输出：['c', 'a']

解析：sorted()按值排序键，取前N个得到Top N结果，常用于排行榜等场景。

95. 题目：字典中值的类型转换

需求：将{"a": "1", "b": "2", "c": "3"}中的值从字符串转为整数。

my_dict = {"a": "1", "b": "2", "c": "3"}
converted = {k: int(v) for k, v in my_dict.items()}
print(converted)  # 输出：{'a': 1, 'b': 2, 'c': 3}

解析：字典推导式中用int(v)将字符串值转为整数，适用于数据类型转换。

96. 题目：用字典实现开关语句（替代if-elif）

需求：根据输入的操作符（“+”, “-”, “*”, “/”)执行对应运算，用字典实现。

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    return a / b if b != 0 else "除数不能为0"

# 用字典映射操作符到函数
operations = {
    "+": add,
    "-": subtract,
    "*": multiply,
    "/": divide
}

a, op, b = 10, "+", 5
result = operations.get(op, lambda x, y: "无效操作符")(a, b)
print(result)  # 输出：15

解析：字典的值可以是函数，通过键映射到对应函数并调用，比if-elif更简洁，适合多分支场景。

97. 题目：嵌套字典中查找所有符合条件的值

需求：在{"A": {"x": 10, "y": 20}, "B": {"z": 15}}中找出所有大于15的值，返回[20]。

def find_values(nested, condition):
    values = []
    for v in nested.values():
        if isinstance(v, dict):
            # 递归查找嵌套字典
            values.extend(find_values(v, condition))
        else:
            if condition(v):
                values.append(v)
    return values

nested = {"A": {"x": 10, "y": 20}, "B": {"z": 15}}
# 查找大于15的值
result = find_values(nested, lambda x: x > 15)
print(result)  # 输出：[20]

解析：递归遍历嵌套字典，收集所有满足条件的值，condition为判断函数，灵活适配不同条件。

98. 题目：字典中键的模糊匹配

需求：从{"name": "张三", "age": 18, "nationality": "中国"}中找出包含"na"的键，返回["name", "nationality"]。

my_dict = {"name": "张三", "age": 18, "nationality": "中国"}
# 筛选键中包含"na"的键（不区分大小写）
matching_keys = [k for k in my_dict if "na" in k.lower()]
print(matching_keys)  # 输出：['name', 'nationality']

解析：列表推导式筛选键中包含指定子串的键，k.lower()实现不区分大小写匹配。

99. 题目：合并两个字典，保留相同键的原值

需求：合并{"a": 1, "b": 2}和{"b": 3, "c": 4}，相同键保留第一个字典的值，结果{"a":1, "b":2, "c":4}。

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
# 方法1：先拷贝d1，再更新d2中d1没有的键
merged = d1.copy()
for k, v in d2.items():
    if k not in merged:
        merged[k] = v
# 方法2：字典解包（d2在后会覆盖d1，不适用；此处用d1解包后更新d2中不存在的键）
# merged = {**d2,** d1}  # 错误，会覆盖
print(merged)  # 输出：{'a': 1, 'b': 2, 'c': 4}

解析：先拷贝第一个字典，再添加第二个字典中不存在的键，确保相同键保留原值。

100. 题目：用字典实现词频统计并排序

需求：统计"hello world hello python"中每个单词的出现次数，并按频率降序排序。

s = "hello world hello python"
words = s.split()  # 分割为单词列表

# 统计词频
word_counts = {}
for word in words:
    word_counts[word] = word_counts.get(word, 0) + 1

# 按频率降序排序
sorted_counts = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
print(sorted_counts)  # 输出：[('hello', 2), ('world', 1), ('python', 1)]

解析：先分割字符串为单词，统计每个单词的出现次数，再按频率排序，是文本分析的基础操作。

总结

以上100题全面覆盖了Python字典的核心知识点，从基础的创建、访问到进阶的嵌套字典处理、字典推导式，再到综合应用场景（如统计、转换、排序）。字典作为Python中存储键值对的核心数据结构，在数据处理、配置管理、缓存等场景中应用广泛。

练习时需注意：字典的键必须是不可变类型（字符串、数字、元组等）；Python 3.7+字典保留插入顺序；嵌套字典的深拷贝与浅拷贝区别；字典推导式与循环的效率差异等。通过这些题目，可系统掌握字典的使用技巧，为复杂编程任务打下基础。

万字长文探秘Redis：开发者必备的完全指南
Xayla的博客
03-31 1454
Redis是一款基于键值对的NoSQL数据库，它的值支持多种数据结构，比如，字符串，哈希，列表，集合，有序集合()等。Redis将所有的数据都存放在内存中，所以它的读写性能方面堪称秀儿。同时，它还可以将内存中的数据以快照或日志的形式保存在硬盘上，以保证数据的安全性。Redis典型的应用场景包括：缓存、排行榜、计数器、社交网络、消息队列等等。官网Windows版本下载简单动态字符串(SDS)，是的缩写，是Redis内部自定义实现的一种数据类型。在Redis数据库内部，包含字符串的键值对在底层都是由SDS。
万字博文教你python爬虫Beautiful Soup库【详解篇】
热门推荐
孤寒者的博客
07-22 56万+
万字博文教你python爬虫Beautiful Soup库【详解篇】
Python练习题---字典
m0_68976043的博客
07-20 6812
9、现有dict2 = {"k1": "v11", "a": "b"}, 通过一行操作使dict2 = {"k1": "v1", "k2": "v2", "k3": "v3", "a": "b"}6、请删除字典中键"k5"对应的键值对，如果字典中不存在键"k5", 则不报错，返回None。8、请获取字典中"k6"对应的值, 如果不存在，则不报错，并且让其返回None。4、请在字典中增加一个键值对, "k4": "v4"，输出添加后的字典。5、请删除字典中键值对 "k1": "v1", 并输出删除后的结果。
加班熬夜整理出来的100道Python基础题，学到就是赚到！超级详细
10-13 3万+
这不每天晚上下班了无聊，就给大家整理出来了一百道Python必刷题，基本上都做的出来的话，基础彻底没问题了~ 大致涉及到的知识点有： 基础语法 变量类型 运算符 条件判断 循环 字符串 列表 元组 字典 函数 异常 内置函数 面向对象 正则表达式 异常处理 … OK，我们开始今天的正题吧 第1题 问题：编写一个程序，找到2000年至3200年(包括在内)中所有可被7整除但不能被5整除的所有数字，得到的数字按逗号分隔，打印在一行上。 提示：考虑使用range(begin, end)方法 第2题 问题
python字典练习题
weixin_45878889的博客
02-24 3237
通过几道python字典(dict)练习题来巩固对字典的掌握, 考察你对python字典常用方法的理解和使用,比如keys(), values(),如何判断一个key是否在字典中, 如何用字典来存储并表示数据。二、 字典应用（买水果）三、字典应用（买水果2）
Python字典实战题目练习，巩固知识、检查技术
小白的大数据之旅的博客
09-12 2790
本文主要是作为Python中列表的一些题目，方便学习完Python的列表之后进行一些知识检验，感兴趣的小伙伴可以试一试，含选择题、判断题、实战题，。通过这些题目，学习者可以检验自己对Python字典基础知识的掌握程度。编程不仅是技术的堆砌，更是灵魂的创造，每一次代码的跳动，都是向世界宣告你的不凡！
Python入门习题----数字出现次数排序
不祈求 ~ ~
10-16 7649
【问题描述】 给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。 【输入形式】 第一行包含一个整数n，表示给定数字的个数; 第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。 【输出形式】 输出有多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的...
Python保姆级教程(十二):学习资源与进阶方向
最新发布
分享知识，拥抱变化
08-07 1194
摘要：本文为Python学习者提供系统化的进阶指南，涵盖从入门到精通的完整学习路径。首先推荐权威学习资源，包括官方文档、经典书籍和在线课程，并分类整理数据分析、Web开发、自动化脚本等主流应用方向的核心技能与实战案例。特别强调实践的重要性，建议通过LeetCode、Kaggle等平台练习，参与开源项目。针对常见学习困境，提出"小步快跑"策略：每日学习新知识，每周完成小功能，每月搞定小项目。文章指出兴趣驱动和持续输出是突破瓶颈的关键，建议选择一个方向深耕后再扩展领域，最终将Python转化
Python 3.8.20新手必备：一步搞定环境搭建与故障排除
[Python 3.8.20新手必备：一步搞定环境搭建与故障排除](https://cdn.shopify.com/s/files/1/0533/2089/files/sublime-text-plugins.jpg?v=1522173618) 参考资源链接：[Python 3.8.20跨平台安装包正式发布]...
python数据可视化分析报告,数据分析与可视化python
super67269的博客
08-12 3852
2、Tensorflow相关的基本概念，TF数据流图、会话、张量、tensorboard可视化、张量修改、TF文件读取、tensorflowplayround使用、神经网络结构、卷积计算、激活函数计算、池化层设计，掌握机器学习和深度学习之前的区别和练习，熟练掌握深度学习基本工作流程，熟练掌握神经网络的结构层次及特点，掌握张量、图结构、OP对象等的使用，熟悉输入层、卷积层、池化层和全连接层的设计，完成验证码识别、图像识别、手写输入识别等常见深度学习项目全程实战。...
python教程：11种字典常见操作
桃子同学的博客
09-13 638
python教程：11种字典常见操作。温故知新。
【附实例】Python字典的各种操作
zhang120529的博客
09-24 2058
Python 字典是一种可变容器模型，且可存储任意类型对象。
SDUT—Python程序设计实验六(字典与集合)
qq_51774501的博客
11-11 5338
已知字典中有n个单词，现有m个不认识的单词，询问这m个单词是否出现在字典中，如果在字典中就输出其含义，如果不在字典中，就输出：Not found!图中有若干个顶点，每个顶点的表示方式为：顶点名称和该顶点相连的所有的其他顶点的名称，所组成的边的长度。第一行输入n，m (n>=0&&n=0&&m
字典深入学习及练习题---Python
blue_2021010615的博客
07-24 857
v1 = {}data = {"k1":1,"k2":2info = {"age":12,"hobby":['篮球','足球']字典中对键值得要求：键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）值：任意类型。True:5,123:5,# 不合法v1 = {[1, 2, 3]: '周杰伦',"age" : 18v2 = {{1,2,3}: "哈哈哈",​v3 = {
python字典操作题_Python字典练习题
weixin_39802969的博客
11-30 1738
有字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"}，实现以下功能：1、遍历字典 dic 中所有的key参考答案：2、遍历字典 dic 中所有的value参考答案：3、循环遍历字典 dic 中所有的key和value参考答案：4、添加一个键值对"k4","v4",输出添加后的字典 dic参考答案：5、删除字典 dic 中的键值对"k1","v1",并输出删除...
Python Day9 字典（dict）详解 及 例题分享
ihghhfffv的博客
07-10 1556
Python字典知识体系摘要 字典是Python中以键值对存储数据的核心数据结构，具有以下特点： 键必须为不可变类型且唯一，值可为任意类型 创建方式包括字面量定义、dict()函数和推导式 支持增删改查操作：通过[key]语法添加/修改，pop/del删除，get/[key]查询 常用方法：setdefault()安全添加、update()合并字典、items()遍历键值对 运算符：|合并字典、in判断键存在、==比较字典内容 典型应用场景包括数据聚合、配置管理、对象属性存储等 实际案例涵盖学生管理系统、数
【每日一练】python入门级字典的常用操作
程之编的博客
06-30 135
python入门级字典的常用操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值