一、问答题
（1）列表和元组的区别是什么?如何从列表创建元组?如何从元组创建列表?
答：区别：列表是可变的数据类型，可以对列表中的元素进行添加、删除、修改等操作。元组是不可变的数据类型，一旦创建其中的元素就不能进行添加、删除、修改等操作。
可以用
tuple()函数将列表转换为元组，可以用list()函数将元组转换为列表。
（2）下面代码的错误是什么?
t=(1,2.3)
t.append(4)
t.remove(0)
t[0]=1
答：元组是不可变数据类型，不能进行增删操作，所以下面代码错误。
t.append(4)
t.remove(0)
（3）下面的代码正确吗?
t1 = (1,2,3,7,9,0,5)
t2 = (1,2,5)
t1 = t2
答：代码是正确的，但是
t1 = t2是将t2对应的元组赋值给t1,所以t2和t1都指向元组(1,2,5)。
（4）给出下面代码的输出?
t1=(1,2,3,7,9,0,5)
t2=(1,3,22,7,9,0,5)
print(t1 == t2)
print(t1 != t2)
print(t1 > t2)
print(t1 < t2)
答：输出：
False True False True
（5）列表、集合或元组能有不同类型的元素吗?
答：可以有不同类型的元素。列表是可变序列，集合是无序且唯一的数据结构，元组是不可变序列，都可以包含不同类型的元素。
（6）下面哪个集合是被正确创建的?
s ={1,3,4}
s ={{1,2},{4,5}}
s ={[1,2],[4,5]}
s ={(1,2),(4,5)}
答：集合是可变类型，但是里面的元素是可哈希的，所以元素必须是不可变的。
正确的集合应该是：
s ={1,3,4} s ={(1,2),(4,5)}
（7）给出下面代码的输出。
students ={"peter","john"}
print(students)
students.add("john")
print(students)
students.add("peterson")
print(students)
students.remove("peter")
print(students)
答：
{'john', 'peter'} {'john', 'peter'} {'john', 'peterson', 'peter'} {'john', 'peterson'}
（8）给出下面代码的输出。
student1 ={"peter"，"john"，"tim"}
student2 ={"peter","johnson"，"tim"}
print(student1.issuperset({"john"}))
print(studentl.issubset(student2))
print({1，2，3} > {1，2，4})
print({1，2，3} < {1，2，4})
print({1，2} < {1，2，4})
print({1，2} <= {1，2，4})
答：
True False False False True True
（9）给出下面代码的输出。
s1={1，4，5，6}
s2={1，3，6，7}
print(s1.union(s2))
print(s1 | s2)
print(s1.intersection(s2))
print(s1 & s2)
print(s1.difference(s2))
print(s1 - s2)
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
答：
{1, 3, 4, 5, 6, 7} {1, 3, 4, 5, 6, 7} {1, 6} {1, 6} {4, 5} {4, 5} {3, 4, 5, 7} {3, 4, 5, 7}
（10）给出下面代码的输出。
set1 = {1，2，3}
set2 = {3，4，5}
set3 = set1 | set2
print(set1,set2,set3)
set3 = set1 - set2
print(set1，set2，set3)
set3=set1 & set2
print(set1,set2,set3)
set3=set1 ^ set2
print(set1，set2，set3)
答：
{1, 2, 3} {3, 4, 5} {1, 2, 3, 4, 5} {1, 2, 3} {3, 4, 5} {1, 2} {1, 2, 3} {3, 4, 5} {3} {1, 2, 3} {3, 4, 5} {1, 2, 4, 5}
（11）下面哪个字典是被正确创建的?
d={1:[1，2]，3:[3，4]}
d={[1，2]:1，[3，4]:3}
d={(1，2):1，(3，4):3}
d={1:"john", 3:"peter"}
d={"john":1,"peter":3}
答：字典的键是可哈希的，所以字典的键必须是不可变类型。
正确的：
d={1:[1，2]，3:[3，4]}
d={(1，2):1，(3，4):3}
d={1:“john”, 3:“peter”}
d={“john”:1,“peter”:3}不正确的：d={[1，2]:1，[3，4]:3} ，列表是可变的，所以无法作为键。
（12）假设一个名为 students 的字典是 {“john”:3,“peter”:2}。下面的语句实现什么功能?
(a) print(len(students))
(b) print(students.keys())
(c) print(students.values())
(d) print(students.items())
答：(a)获取键值对的长度。
(b)获取字典students的键。
©获取字典students的值。
(d)获取字典students的键值对。
（13）给出下面代码的输出。
def main():
d = {"red":4,"blue":1,"green":14,"yellow":2}
print(d["red"])
print(list(d.keys()))
print(list(d.values))
print("blue" in d)
print("purple" in d)
d["blue"] += 10
print(d["blue"])
main() #Call the main function
答：
4 ['red', 'blue', 'green', 'yellow'] [4, 1, 14, 2] True False 11
（14）给出下面代码的输出。
def main():
d = {}
d["susan"]= 50
d["jim"]= 45
d["joan"]= 54
d["susan"]= 51
d["john"]= 53
print(len(d))
main() #Call the main function
答：字典的键具有唯一性，上述代码中只有"susan"对应的值更新了。
4
二、编程题
（15）学生成绩统计
学校记录了学生们多门课程的成绩，每门课程成绩以字典形式存储，学生姓名作为键，成绩作为值。现在需要统计每个学生的平均成绩，并找出平均成绩最高的学生。
# 每门课学生的成绩
course_scores = [
{'Alice': 85, 'Bob': 90, 'Charlie': 78},
{'Alice': 92, 'Bob': 88, 'Charlie': 85},
{'Alice': 79, 'Bob': 94, 'Charlie': 82}
]
# 每门课学生的成绩
course_scores = [
{'Alice': 85, 'Bob': 90, 'Charlie': 78},
{'Alice': 92, 'Bob': 88, 'Charlie': 85},
{'Alice': 79, 'Bob': 94, 'Charlie': 82}
]
#用于存储每个学生的总成绩
total_scores = {}
#课程数量
num_courses = len(course_scores)
for scores in course_scores:
for student, score in scores.items():
if student not in total_scores:
total_scores[student] = 0
total_scores[student] += score
#存储每个学生的平均成绩
average_scores = {}
for student, total in total_scores.items():
average_scores[student] = total / num_courses
#找出平均成绩最高的学生
heighest_student = max(average_scores, key=average_scores.get)
heighest_score = average_scores[heighest_student]
#输出每个学生的平均成绩
for student, average in average_scores.items():
print(f"{student}的平均成绩是：{average:.2f}")
print(f"平均成绩最高的学生是{heighest_student},平均成绩{heighest_score:.2f}")
（16）商品库存管理
一家商店有多个商品的库存信息，以字典形式存储，键为商品名称，值为库存数量。每天会有新的进货和销售记录，需要更新库存信息。如果库存数量变为负数，则输出警告信息。
# 初始货物量
inventory = {'苹果': 100, '香蕉': 80, '橙子': 120}
# 进货/销售记录
transactions = [
{'苹果': -20, '香蕉': 30},
{'橙子': -50, '苹果': 10}
]
# 初始货物量
inventory = {'苹果': 100, '香蕉': 80, '橙子': 120}
# 进货/销售记录
transactions = [
{'苹果': -20, '香蕉': 30},
{'橙子': -50, '苹果': 10}
]
for transaction in transactions:
for item, quantity in transaction.items():
#更新库存信息
inventory[item] = inventory.get(item, 0) + quantity
#为负数发出警告
if inventory[item] < 0:
print(f"商品{item}数量为负数，当前存量为{inventory[item]}")
#输出更新后的库存信息
print("更新后的库存信息：")
for item, quantity in inventory.items():
print(f"{item}:{quantity}")
（17）社交网络好友关系【录制讲解】
**视频链接：**录制文件：https://meeting.tencent.com/crm/KeZYRawW4f
在一个社交网络中，用户之间的好友关系用字典表示，键为用户名称，值为该用户的好友集合。现在需要找出哪些用户是所有用户的共同好友。
# 好友关系表
friendships = {
'Alice': {'Bob', 'Charlie', 'David'},
'Bob': {'Alice', 'Charlie'},
'Charlie': {'Alice', 'Bob', 'David'},
'David': {'Alice', 'Charlie'}
}
# 好友关系表
friendships = {
'Alice': {'Bob', 'Charlie', 'David'},
'Bob': {'Alice', 'Charlie'},
'Charlie': {'Alice', 'Bob', 'David'},
'David': {'Alice', 'Charlie'}
}
#将用户加入到好友集合中
for user, friends in friendships.items():
updated_friendships = {user: friends.union({user})}
#将所有好友集合加入到列表中
all_friend_sets = list(updated_friendships.values())
#求交集
if all_friend_sets:
common_friends = set.intersection(*all_friend_sets)
else:
common_friends = set()
print("所有用户的共同好友是：", common_friends)
（18）在线游戏玩家组队匹配python
在线游戏中有多个玩家，每个玩家有不同的游戏角色和技能等级，用字典表示，键为玩家名，值为角色和技能等级的字典。现在要根据玩家的角色和技能等级进行组队匹配，使每个队伍的综合实力尽量均衡。
# 玩家数据
players = {
'Player1': {'Warrior': 80, 'Mage': 20},
'Player2': {'Warrior': 30, 'Mage': 70},
'Player3': {'Warrior': 60, 'Mage': 40},
'Player4': {'Warrior': 40, 'Mage': 60}
}
# 玩家数据
players = {
'Player1': {'Warrior': 80, 'Mage': 20},
'Player2': {'Warrior': 30, 'Mage': 70},
'Player3': {'Warrior': 60, 'Mage': 40},
'Player4': {'Warrior': 40, 'Mage': 60}
}
# 初始化一个空字典，用于存储每个玩家的综合实力
player_strength = {}
# 遍历玩家数据字典
for player, roles in players.items():
strength = 0
for role_strength in roles.values():
strength = strength + role_strength
player_strength[player] = strength
# 根据综合实力对玩家进行排序，得到一个元组列表，每个元组包含玩家名字和综合实力
# 使用 sorted 函数，key 参数指定按照元组的第二个元素（综合实力）进行排序
# reverse=True 表示降序排序
sorted_players = sorted(player_strength.items(), key=lambda x: x[1], reverse=True)
num_teams = 2
teams = []
for _ in range(num_teams):
teams.append([])
# 交替组队，遍历排序后的玩家列表
for i, (player, _) in enumerate(sorted_players):
# 计算当前玩家应该加入的队伍索引，通过取模运算实现交替
team_index = i % num_teams
# 将当前玩家添加到对应的队伍中
teams[team_index].append(player)
# 输出组队结果
for i, team in enumerate(teams):
# 格式化输出队伍编号和队伍中的玩家
team_number = i + 1
print(f"队伍 {team_number}: {team}")
（19）餐厅菜品搭配分析
餐厅有多个菜品分类，每个分类有不同的菜品，用字典表示，键为分类名，值为菜品集合。现在要找出所有可能的菜品搭配，每个搭配包含主菜、配菜和饮品。
# 菜品分类信息
menu_categories = {
'主菜': {'牛排', '披萨', '寿司'},
'配菜': {'薯条', '沙拉', '烤蔬菜'},
'饮品': {'可乐', '咖啡', '果汁'}
}
import itertools
# 菜品分类信息
menu_categories = {
'主菜': {'牛排', '披萨', '寿司'},
'配菜': {'薯条', '沙拉', '烤蔬菜'},
'饮品': {'可乐', '咖啡', '果汁'}
}
#获取主菜、配菜、饮品
main_courses = menu_categories['主菜']
side_dishes = menu_categories['配菜']
drinks = menu_categories['饮品']
#生成所有可能的搭配
combinations = list(itertools.product(main_courses, side_dishes, drinks))
#输出所有可能的搭配
for combination in combinations:
print(f"主菜：{combination[0]},配菜：{combination[1]},饮品：{combination[2]}")
（20）科研项目人员分配优化【录制讲解】
**视频链接：**录制文件：https://meeting.tencent.com/crm/KmvyejJbe1
有多个科研项目，每个项目需要不同技能的人员，用字典表示，键为项目名，值为所需技能集合。同时有多个研究人员，每个人员具备的技能也用集合表示。现在要为每个项目分配合适的人员，使每个项目尽量满足所需技能。
# 项目及技能需求
projects = {
'ProjectA': {'Python', '数据分析', '机器学习'},
'ProjectB': {'Java', '数据库管理', '算法设计'},
'ProjectC': {'C++', '图像处理', '计算机视觉'}
}
# 人员及具备技能
researchers = {
'Researcher1': {'Python', '数据分析'},
'Researcher2': {'Java', '数据库管理'},
'Researcher3': {'C++', '图像处理'},
'Researcher4': {'机器学习', '算法设计', '计算机视觉'}
}
# 项目及技能需求
projects = {
'ProjectA': {'Python', '数据分析', '机器学习'},
'ProjectB': {'Java', '数据库管理', '算法设计'},
'ProjectC': {'C++', '图像处理', '计算机视觉'}
}
# 人员及具备技能
researchers = {
'Researcher1': {'Python', '数据分析'},
'Researcher2': {'Java', '数据库管理'},
'Researcher3': {'C++', '图像处理'},
'Researcher4': {'机器学习', '算法设计', '计算机视觉'}
}
project_assigment = {}
#遍历每一个项目
for project, skills_needed in projects.items():
best_researcher = None
max_skills_matched = 0
#遍历每个研究人员
for researcher, skills_possessed in researchers.items():
#计算满足技能的数量
skills_matched = len(skills_needed.intersection(skills_possessed))
#更新最佳人员
if skills_matched > max_skills_matched:
max_skills_matched = skills_matched
best_researcher = researcher
#分配人员
project_assigment[project] = best_researcher
#输出
for project, researcher in project_assigment.items():
print(f"{project} 分配给 {researcher}")
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
