笔记：Python字典和集合编程题（练习题）

最新推荐文章于 2024-05-19 00:08:58 发布

辞言i

最新推荐文章于 2024-05-19 00:08:58 发布

阅读量1.1k

点赞数 24

文章标签：笔记 python

本文链接：https://blog.csdn.net/qq_25594453/article/details/138165303

版权

文章目录

前言
一、Python字典和集合是什么？
二、编程题
总结

前言

Python字典和集合编程题（练习题）

欢迎来到Python字典和集合编程题的练习！本练习旨在帮助您巩固和提升对Python中字典和集合的理解和应用能力。

字典和集合是Python中非常重要的数据结构，它们能够以高效的方式存储和操作数据。本练习将涵盖字典和集合的各种常见用法和技巧，并通过一系列编程问题来帮助您加深对这些概念的理解。

在完成本练习后，您将能够：

熟练使用字典和集合进行数据存储和检索。
理解字典和集合的基本操作，如添加、删除和更新元素。
利用字典和集合解决实际问题，并写出简洁而高效的代码。

每个练习题都配有详细的问题描述和示例输入输出，您可以根据需求自行选择Python 3来解决这些问题。

祝您在这个练习中取得成功，并加深对Python字典和集合的理解！

一、Python字典和集合是什么？

在Python中，字典（Dictionary）和集合（Set）是两种常用的数据结构，用于存储和操作数据。

字典：
- 字典是一种键值对（key-value pairs）的数据结构，其中每个值都与唯一的键相关联。
- 键必须是不可变的类型，通常是字符串、整数或元组，而值可以是任意类型的数据。
- 字典是可变的，可以动态地添加、删除或修改键值对。
- 字典中的键是唯一的，但值可以重复。
- 字典是通过大括号 {} 来创建的，键值对之间使用冒号 : 分隔，每对键值对之间使用逗号 , 分隔。
集合：
- 集合是一种无序且元素唯一的数据结构，用于存储不重复的元素。
- 集合中的元素必须是不可变的类型，例如数字、字符串或元组，集合本身是可变的。
- 集合支持基本的集合操作，如并集、交集、差集等。
- 集合是通过大括号 {} 来创建的，其中包含一个或多个元素，每个元素之间使用逗号 , 分隔。

字典和集合在Python中非常常用，它们提供了高效的数据存储和检索功能，并在许多实际应用中发挥着重要作用，如数据处理、算法实现、以及程序设计中的各种问题解决方案。

二、编程题

1. 计算字典中值的总和

# 题目：计算字典中所有值的总和
# 字典示例
sample_dict = {'a': 100, 'b': 200, 'c': 300}

# 初始化总和为0
total_sum = 0

# 遍历字典的值，将其加入总和
for value in sample_dict.values():
    total_sum += value

# 打印结果
print("字典中值的总和为:", total_sum)

解析：

我们使用 sample_dict.values() 方法来获取字典中的所有值。
然后，我们使用一个循环来遍历这些值，并将它们加入总和 total_sum 中。
最后，我们打印出总和的值。

2. 合并两个字典

# 题目：合并两个字典
dict1 = {'a': 100, 'b': 200}
dict2 = {'x': 300, 'y': 200}

# 使用update()方法合并字典
dict1.update(dict2)

# 打印合并后的字典
print("合并后的字典:", dict1)

解析：

我们使用 update() 方法将 dict2 中的键值对更新到 dict1 中。
这样就实现了字典的合并，dict1 包含了 dict2 中的键值对。
最后，我们打印合并后的字典 dict1。

3. 计算字典中的键值乘积

# 题目：计算字典中的键值乘积
sample_dict = {'a': 4, 'b': 3, 'c': 2}

# 使用列表推导式计算键值乘积
result = 1
for key, value in sample_dict.items():
    result *= value

# 打印结果
print("字典中的键值乘积为:", result)

解析：

我们使用 sample_dict.items() 来获取字典中的键值对。
然后，我们使用一个循环遍历这些键值对，并将它们的值相乘。
最后，我们打印出结果。

4. 检查两个字典是否有相同的键

# 题目：检查两个字典是否有相同的键
dict1 = {'a': 100, 'b': 200, 'c': 300}
dict2 = {'x': 300, 'y': 200, 'z': 400}

# 检查是否有相同的键
common_keys = dict1.keys() & dict2.keys()

# 如果存在相同的键，打印它们
if common_keys:
    print("存在相同的键:", common_keys)
else:
    print("没有相同的键")

解析：

我们使用 & 运算符获取两个字典中的相同键。
如果存在相同的键，我们打印出这些相同的键。
否则，我们打印出没有相同键的信息。

5. 删除字典中的特定键

# 题目：删除字典中的特定键
sample_dict = {'a': 100, 'b': 200, 'c': 300}

# 删除键 'a'
if 'a' in sample_dict:
    del sample_dict['a']

# 打印删除键后的字典
print("删除键 'a' 后的字典:", sample_dict)

解析：

我们使用 del 关键字删除字典中的特定键。
在删除之前，我们先使用 in 关键字检查该键是否存在于字典中。
最后，我们打印出删除键后的字典。

6. 查找字典中的最大值和最小值

# 题目：查找字典中的最大值和最小值
sample_dict = {'a': 100, 'b': 200, 'c': 300}

# 使用max()和min()函数查找最大值和最小值
max_value = max(sample_dict.values())
min_value = min(sample_dict.values())

# 打印结果
print("最大值:", max_value)
print("最小值:", min_value)

解析：

我们使用 max() 函数和 min() 函数来找到字典中值的最大值和最小值。
max(sample_dict.values()) 返回字典中值的最大值，min(sample_dict.values()) 返回最小值。
最后，我们打印出结果。

7. 统计字符串中每个字符的出现次数

# 题目：统计字符串中每个字符的出现次数
sample_str = "hello"

# 使用字典统计字符出现次数
char_count = {}
for char in sample_str:
    char_count[char] = char_count.get(char, 0) + 1

# 打印结果
print("每个字符的出现次数:", char_count)

解析：

我们使用一个空字典 char_count 来存储每个字符的出现次数。
然后，我们遍历字符串中的每个字符，并使用 char_count.get(char, 0) + 1 来更新字符出现次数。
如果字符不在字典中，则使用 get() 方法返回默认值0，并将其加1。
最后，我们打印出每个字符的出现次数。

8. 使用字典实现计数器

# 题目：使用字典实现计数器
# 初始化计数器
counter = {}

# 统计元素出现次数
elements = [1, 2, 1, 2, 3

, 1, 2, 1, 2, 3, 4, 5, 4, 3, 4, 5, 4, 5]
for element in elements:
    counter[element] = counter.get(element, 0) + 1

# 打印结果
print("计数器:", counter)

解析：

我们使用一个空字典 counter 来实现计数器。
然后，我们遍历列表中的每个元素，并使用 counter.get(element, 0) + 1 来更新元素的出现次数。
如果元素不在字典中，则使用 get() 方法返回默认值0，并将其加1。
最后，我们打印出计数器的结果。

9. 求两个集合的差集

# 题目：求两个集合的差集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 计算差集
difference = set1 - set2

# 打印结果
print("差集:", difference)

解析：

我们使用 - 运算符来计算两个集合的差集。
set1 - set2 表示在 set1 中但不在 set2 中的元素。
最后，我们打印出差集的结果。

练习2

10. 判断集合是否是另一个集合的子集

# 题目：判断集合是否是另一个集合的子集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}

# 判断是否是子集
is_subset = set1.issubset(set2)

# 打印结果
if is_subset:
    print("set1 是 set2 的子集")
else:
    print("set1 不是 set2 的子集")

解析：

我们使用 issubset() 方法来判断 set1 是否是 set2 的子集。
如果 set1 是 set2 的子集，则返回 True，否则返回 False。
最后，我们根据判断结果打印相应的信息。

1. 计算字典中值为偶数的键的总和

# 题目：计算字典中值为偶数的键的总和
sample_dict = {'a': 3, 'b': 4, 'c': 5, 'd': 6}

# 初始化总和为0
even_sum = 0

# 遍历字典的键值对
for key, value in sample_dict.items():
    # 判断值是否为偶数
    if value % 2 == 0:
        # 如果是偶数，则加入总和
        even_sum += key

# 打印结果
print("值为偶数的键的总和为:", even_sum)

解析：

我们遍历字典中的键值对。
使用取模运算符 % 来判断值是否为偶数。
如果值为偶数，则将对应的键加入到总和中。
最后，打印出值为偶数的键的总和。

2. 合并两个字典，如果有相同的键，将值相加

# 题目：合并两个字典，如果有相同的键，将值相加
dict1 = {'a': 100, 'b': 200, 'c': 300}
dict2 = {'b': 300, 'd': 400}

# 遍历第二个字典的键值对
for key, value in dict2.items():
    # 如果键在第一个字典中，则将值相加
    if key in dict1:
        dict1[key] += value
    else:
        # 如果不在，则添加到第一个字典中
        dict1[key] = value

# 打印合并后的字典
print("合并后的字典:", dict1)

解析：

我们遍历第二个字典中的键值对。
如果键在第一个字典中，则将对应值相加。
如果不在第一个字典中，则将键值对添加到第一个字典中。
最后，打印出合并后的字典。

3. 查找字典中出现次数最多的值

# 题目：查找字典中出现次数最多的值
sample_dict = {'a': 1, 'b': 2, 'c': 2, 'd': 3, 'e': 3, 'f': 3}

# 使用字典推导式统计值出现次数
value_counts = {value: sum(1 for v in sample_dict.values() if v == value) for value in set(sample_dict.values())}

# 找到出现次数最多的值
max_count = max(value_counts.values())
most_frequent_values = [key for key, value in value_counts.items() if value == max_count]

# 打印结果
print("出现次数最多的值:", most_frequent_values)

解析：

我们使用字典推导式统计字典中每个值出现的次数。
使用 max() 函数找到最大的出现次数。
找到具有最大出现次数的值，并存储在 most_frequent_values 列表中。
最后，打印出出现次数最多的值。

4. 将列表转换为字典，键为列表元素，值为元素在列表中的索引

# 题目：将列表转换为字典，键为列表元素，值为元素在列表中的索引
sample_list = ['a', 'b', 'c', 'd', 'e']

# 使用字典推导式生成字典
indexed_dict = {value: index for index, value in enumerate(sample_list)}

# 打印结果
print("转换后的字典:", indexed_dict)

解析：

我们使用 enumerate() 函数遍历列表元素并同时获得索引。
使用字典推导式将列表元素作为键，索引作为值生成字典。
最后，打印出转换后的字典。

5. 检查两个集合是否有相同的元素

# 题目：检查两个集合是否有相同的元素
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 判断是否有相同元素
has_common_elements = len(set1.intersection(set2)) > 0

# 打印结果
if has_common_elements:
    print("集合有相同的元素")
else:
    print("集合没有相同的元素")

解析：

我们使用 intersection() 方法获取两个集合的交集。
如果交集的长度大于0，则表示集合有相同的元素。
最后，根据判断结果打印相应的信息。

6. 求两个集合的并集并去重

# 题目：求两个集合的并集并去重
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 求并集并去重
union_set = set1.union(set2)

# 打印结果
print("并集并去重:", union_set)

解析：

我们使用 union() 方法获取两个集合的并集。
并集操作会自动去除重复的元素。
最后，打印出并集并去重的结果。

7. 删除字典中值小于10的键值对

# 题目：删除字典中值小于10的键值对
sample_dict = {'a': 5, 'b': 15, 'c': 7, 'd': 12}

# 使用字典推导式筛选键值对
filtered_dict = {key: value for key, value in sample_dict.items() if

 value >= 10}

# 打印结果
print("删除值小于10的键值对后的字典:", filtered_dict)

解析：

我们使用字典推导式遍历字典中的键值对。
仅保留值大于等于10的键值对。
最后，打印出删除值小于10的键值对后的字典。

8. 判断集合是否是另一个集合的超集

# 题目：判断集合是否是另一个集合的超集
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4}

# 判断是否是超集
is_superset = set1.issuperset(set2)

# 打印结果
if is_superset:
    print("set1 是 set2 的超集")
else:
    print("set1 不是 set2 的超集")

解析：

我们使用 issuperset() 方法判断 set1 是否是 set2 的超集。
如果 set1 包含了 set2 的所有元素，则返回 True，否则返回 False。
最后，根据判断结果打印相应的信息。

9. 计算两个字典的键的交集

# 题目：计算两个字典的键的交集
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'c': 10, 'd': 20, 'e': 30}

# 计算键的交集
intersection_keys = dict1.keys() & dict2.keys()

# 打印结果
print("键的交集:", intersection_keys)

解析：

我们使用 & 运算符获取两个字典的键的交集。
dict1.keys() & dict2.keys() 返回同时存在于 dict1 和 dict2 中的键。
最后，打印出键的交集。

10. 将两个集合进行差运算，得到第一个集合中不属于第二个集合的元素

# 题目：将两个集合进行差运算，得到第一个集合中不属于第二个集合的元素
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 计算差集
difference_set = set1 - set2

# 打印结果
print("差集:", difference_set)

解析：

我们使用 - 运算符计算两个集合的差集。
set1 - set2 返回在 set1 中但不在 set2 中的元素。
最后，打印出差集。

练习3

1. 将两个列表合并为一个字典，其中一个列表为键，另一个列表为值，要求键值对数量相等

# 题目：将两个列表合并为一个字典，其中一个列表为键，另一个列表为值，要求键值对数量相等
keys = ['a', 'b', 'c']
values = [1, 2, 3]

# 使用字典推导式创建字典
merged_dict = {keys[i]: values[i] for i in range(len(keys))}

# 打印结果
print("合并后的字典:", merged_dict)

解析：

我们使用列表的索引来同时遍历两个列表，保证键和值对应。
使用字典推导式将两个列表合并为一个字典。
最后，打印出合并后的字典。

2. 计算两个字典的值的总和，然后将结果作为新字典的唯一值

# 题目：计算两个字典的值的总和，然后将结果作为新字典的唯一值
dict1 = {'a': 100, 'b': 200, 'c': 300}
dict2 = {'x': 300, 'y': 200, 'z': 400}

# 计算两个字典的值的总和
total_sum = sum(dict1.values()) + sum(dict2.values())

# 创建新字典
result_dict = {'total_sum': total_sum}

# 打印结果
print("新字典:", result_dict)

解析：

我们先分别使用 sum() 函数计算两个字典的值的总和。
将这两个总和相加得到最终的总和。
创建一个新字典，将总和作为唯一的值。
最后，打印出新字典。

3. 删除列表中重复的元素，并保持列表顺序不变

# 题目：删除列表中重复的元素，并保持列表顺序不变
sample_list = [1, 2, 3, 2, 4, 5, 1, 3]

# 使用集合和列表推导式去重
unique_list = list(dict.fromkeys(sample_list))

# 打印结果
print("去重后的列表:", unique_list)

解析：

我们先使用 dict.fromkeys() 创建一个字典，字典的键是列表中的元素，值为 None。
字典的特点是键唯一，这样就去除了重复的元素。
然后，使用 list() 函数将字典转换为列表，保持原始顺序。
最后，打印出去重后的列表。

4. 计算两个集合的对称差

# 题目：计算两个集合的对称差
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 计算对称差
symmetric_difference = set1.symmetric_difference(set2)

# 打印结果
print("对称差:", symmetric_difference)

解析：

我们使用 symmetric_difference() 方法计算两个集合的对称差。
对称差是两个集合的并集减去交集的结果。
最后，打印出对称差。

5. 将字典中的键和值互换位置

# 题目：将字典中的键和值互换位置
sample_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用字典推导式进行键值交换
swapped_dict = {value: key for key, value in sample_dict.items()}

# 打印结果
print("键值交换后的字典:", swapped_dict)

解析：

我们使用字典推导式遍历原始字典的键值对，并将键和值互换位置。
最后，打印出键值交换后的字典。

总结

本练习涵盖了Python字典和集合的各种常见用法和技巧，包括基本操作、遍历、合并、统计、查找等。通过这些练习，我们学习了如何使用字典和集合解决各种实际问题，并且掌握了一些高效的编程技巧。

在字典方面，我们学会了计算值的总和、合并字典、统计键值乘积、检查相同键等操作。而在集合方面，我们学会了求差集、并集、判断子集和超集、计算对称差等操作。

此外，我们还学习了一些高级技巧，比如使用字典推导式、集合操作等，来简化代码并提高效率。这些技巧对于日常的数据处理和算法实现非常有用。

总的来说，字典和集合是Python中非常重要的数据结构，能够以高效的方式存储和操作数据。熟练掌握它们的用法将有助于我们编写简洁、高效的代码，并解决各种实际问题。

辞言i

关注

24
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
笔记：Python字典和集合编程题（练习题）

Python字典和集合编程题（练习题）欢迎来到Python字典和集合编程题的练习！本练习旨在帮助您巩固和提升对Python中字典和集合的理解和应用能力。字典和集合是Python中非常重要的数据结构，它们能够以高效的方式存储和操作数据。本练习将涵盖字典和集合的各种常见用法和技巧，并通过一系列编程问题来帮助您加深对这些概念的理解。熟练使用字典和集合进行数据存储和检索。理解字典和集合的基本操作，如添加、删除和更新元素。利用字典和集合解决实际问题，并写出简洁而高效的代码。
复制链接

扫一扫