python基础 面向练习学习python1
- 1. 电话查询
- 问题描述
- 1. 问题分析
- 1. 输入输出分析
- 2. 需求分析：将题目的数据存储并查询
- 2. 所需知识： python 数据存储的类型
- 3. 确定数据存储类型
- 4. 如何书写代码
- 拓展 从键盘中添加或删除联系人
- 5. 回到数据查询 代码
- 拓展 功能增加
- 2. 代码
- 1. 题目详细部分
- 输入输出要求
- **输入输出示例**
- 2. 最终提交代码
- 2. 成绩统计(列表版)
- 问题描述
- 1. 问题分析
- 1. 输入输出分析
- 2. 需求分析: 读取键盘输入内容，存储在列表中，并计算平均分，和找出前三名
- 3. 所需知识: python读取键盘内容的数据类型，如何转化为列表，列表如何计算平均值，列表如何排序并输出成绩前三最大数
- 1. python读取键盘输入内容(input)的数据类型
- 2. 将字符串转化为列表的方法
- 1. **使用 `split()` 方法**：
- 2. **使用列表推导式**：
- 3. **使用 `list()` 函数**：
- 4. **使用正则表达式**：
- 3. 列表如何计算平均值
- 拓展：获取列表中对象的个数 : len( )
- 使用方法
- 示例
- 注意事项
- 4. 列表如何排序
- 5. 获取列表中确定位置的值
- 4. 书写代码
- 2. 代码
- 3. **补考几科（列表）**
- 问题描述
- 1.问题分析
- 1. 输入输出分析
- 2. 需求分析 : 读取每行输入每门课程的成绩，如何转化为列表，计算平均分和 要补考的门数
- 3. 所需知识 : python如何把每行输入的成绩转化为列表，列表计算平均分，列表筛选出小于60分的门数。
- 1. python 多行输入存储
- 2. 列表计算平均分
- 3. 列表筛选出小于60分的门数
- 使用列表推导式
- 使用 `filter()` 函数
- 4. 书写代码
- 2. 代码
- 4. 课程及其编码保存为字典
- 问题描述
- 1. 问题分析
- 1. 输入输出分析
- 2. 需求分析: 输入格式存储为字典，向字典中添加键值对，修改其中的键值对，删除其中的键值对，排序字典的键值对并输出
- 3. 所需知识: python 如何将输入格式存储为字典， 字典的增删改查操作如何实现，字典排序如何实现
- 1. python 如何将输入 格式存储为字典
- 2. 字典的增删改查操作如何实现
- 1. **添加键值对：**
- 2. **修改键值对：**
- 3. **删除键值对：**
- 4. **查询键值对：**
- 3.字典排序如何实现
- 5. 拓展: 使用update() 完成字典的增加操作
- 6. 拓展: 使用 pop() 方法删除字典中指定键的键值对
- 4.书写代码
- 2. 代码
- 优化代码
- 输出要求键值对变换
1. 电话查询
问题描述
定义一个电话簿，里头设置以下联系人：
‘mayun’:‘13309283335’,
‘zhaolong’:‘18989227822’,
‘zhangmin’:‘13382398921’,
‘Gorge’:‘19833824743’,
‘Jordan’:‘18807317878’,
‘Curry’:‘15093488129’,
‘Wade’:'19282937665’
现在输入人名，查询他的号码。
1. 问题分析
1. 输入输出分析
输入：人名
输出：电话号码
2. 需求分析：将题目的数据存储并查询
我们要解决几个问题，
数据的存储，数据的查询，
首先如何存储数据？
输入人名，输出电话号码，
人名相当于是地址标记，电话号码是数据，
但是不是，如果输入电话号码查找人名该怎么办呢？
所以，他们应该是同等的，
两个数据链接起来，输入一个可以查找其他的数据就像对象的封装一样，
python有哪个数据类型能完成我的想法？
但是，我们要先知道python里面有哪些数据类型
2. 所需知识： python 数据存储的类型
在Python中，有许多种不同的数据类型，每种类型都有其特定的用途和适用场景。下面是一些常见的数据类型以及它们的简要介绍：
-
整数（int）：用于表示整数值，如
-5,0,100等。 -
浮点数（float）：用于表示带有小数部分的数值，如
3.14,-0.001,2.71828等。 -
字符串（str）：用于表示文本数据，由单引号
'或双引号"包裹，如'hello',"world",'123'等。 -
列表（list）：用于存储一系列有序的元素，可以包含不同类型的数据，如
[1, 2, 3],['apple', 'banana', 'orange']等。 -
元组（tuple）：类似于列表，但是元组是不可变的，即不能修改其中的元素，如
(1, 2, 3),('a', 'b', 'c')等。 -
字典（dict）：用于存储键值对，每个键都与一个值相关联，键必须是唯一的，如
{'name': 'John', 'age': 30, 'city': 'New York'}等。 -
集合（set）：用于存储无序、不重复的元素，主要用于去重和集合运算，如
{1, 2, 3},{2, 2, 3, 3, 4, 4}等。 -
布尔值（bool）：用于表示真值或假值，只有两个取值：
True和False。
3. 确定数据存储类型
根据之前的描述，我们需要一个能够存储键值对，并且能够根据键或值进行快速查找的数据类型。在Python中，字典（dict）正是满足这个需求的数据类型。
字典是一种无序的数据集合，它通过键值对的方式来存储数据，每个键对应一个值。这种键值对的存储方式非常灵活，既能够通过键快速查找值，也能够通过值快速查找键。因此，字典非常适合用来存储联系人的名字和对应的电话号码，无论是根据名字查找电话号码，还是根据电话号码查找名字，都能够很方便地完成。
4. 如何书写代码
好的,我们确定了存储的数据类型如何书写存储在字典的代码？
典型的字典存储，直接定义
phone_book = {
'mayun': '13309283335',
'zhaolong': '18989227822',
'zhangmin': '13382398921',
'Gorge': '19833824743',
'Jordan': '18807317878',
'Curry': '15093488129',
'Wade': '19282937665'
}
在这段代码中，我们创建了一个名为 phone_book 的字典，其中每个键都是联系人的名字，对应的值是他们的电话号码。例如，键 'mayun' 对应的值是 '13309283335'，表示马云的电话号码是 13309283335。
可以根据实际情况，添加或修改字典中的键值对，来存储更多的联系人信息。例如，如果想要添加一个新的联系人，可以像这样将新的键值对添加到 phone_book 字典中：
phone_book['new_contact'] = '123456789'
这样，就成功地向电话簿中添加了一个新的联系人信息。
拓展 从键盘中添加或删除联系人
如果想通过键盘输入的方式来增加或删除字典中的值，可以编写一个交互式的程序。
下面是一个示例代码，演示了如何通过用户输入来添加或删除电话簿中的联系人信息：
phone_book = {
'mayun': '13309283335',
'zhaolong': '18989227822',
'zhangmin': '13382398921',
'Gorge': '19833824743',
'Jordan': '18807317878',
'Curry': '15093488129',
'Wade': '19282937665'
}
def add_contact():
# 操作和功能用函数定义，方便调用和整合
name = input("请输入联系人姓名：")
# 接收输入用户的姓名
number = input("请输入联系人电话号码：")
# 接收输入用户的电话号码
phone_book[name] = number
# 默认以姓名为键，电话号码为值
print("已成功添加联系人：{} - {}".format(name, number))
# 展示成功添加的联系人
def delete_contact():
name = input("请输入要删除的联系人姓名：")
# 用户输入键删除 姓名和电话号码
if name in phone_book:
#判断是否存在于电话簿中，健壮性
del phone_book[name]
#删除操作
print("已成功删除联系人：{}".format(name))
# 展示给用户，可以确定是否完成操作
else:
print("未找到联系人：{}".format(name))
# 告诉用户打错了或者已经删除
while True:
# 主程序开始入口
print("\n电话簿操作菜单：")
print("1. 添加联系人")
print("2. 删除联系人")
print("3. 退出程序")
#用户选择页面
choice = input("请选择操作（输入对应数字）：")
#用户需要的操作
if choice == '1':
add_contact()
elif choice == '2':
delete_contact()
elif choice == '3':
print("程序已退出。")
break
else:
#保证程序的健壮性
print("无效的选项，请重新输入。")
这段代码实现了一个简单的电话簿管理程序。程序会不断显示菜单，让用户选择操作。用户可以选择添加联系人、删除联系人或退出程序。根据用户的选择，程序会执行相应的操作，并根据用户输入的信息来更新电话簿中的数据。
但是这个代码有个问题，用户无法看到电话本的电话
我们加一行代码
为了让用户清楚地知道电话簿中已经包含的联系人信息，我们可以在菜单显示之前，添加一个选项来显示当前电话簿的内容。下面是更新后的代码：
phone_book = {
'mayun': '13309283335',
'zhaolong': '18989227822',
'zhangmin': '13382398921',
'Gorge': '19833824743',
'Jordan': '18807317878',
'Curry': '15093488129',
'Wade': '19282937665'
}
def add_contact():
name = input("请输入联系人姓名：")
number = input("请输入联系人电话号码：")
phone_book[name] = number
print("已成功添加联系人：{} - {}".format(name, number))
def delete_contact():
name = input("请输入要删除的联系人姓名：")
if name in phone_book:
del phone_book[name]
print("已成功删除联系人：{}".format(name))
else:
print("未找到联系人：{}".format(name))
def show_phone_book():
print("电话簿内容：")
for name, number in phone_book.items():
print("{} - {}".format(name, number))
while True:
show_phone_book()
print("\n电话簿操作菜单：")
print("1. 添加联系人")
print("2. 删除联系人")
print("3. 退出程序")
choice = input("请选择操作（输入对应数字）：")
if choice == '1':
add_contact()
elif choice == '2':
delete_contact()
elif choice == '3':
print("程序已退出。")
break
else:
print("无效的选项，请重新输入。")
在这个版本中，我们添加了一个新的函数 show_phone_book()，它会遍历电话簿中的每个联系人，并打印出他们的名字和电话号码。在每次用户进行操作之前，我们会先调用这个函数来显示电话簿的内容，这样用户就能清楚地知道当前电话簿中包含哪些联系人信息。
5. 回到数据查询 代码
刚刚我们解决了数据存储的问题现在我们面临数据查询的问题，那么python是如何查询字典呢？
在Python中，你可以使用字典的键来快速查询对应的值。字典内部实现了一种高效的数据结构，使得根据键来查找对应的值具有很高的效率，平均时间复杂度为 O(1)。
你可以通过以下两种方式来查询字典中的值：
-
使用键直接访问值：
phone_book = { 'mayun': '13309283335', 'zhaolong': '18989227822', 'zhangmin': '13382398921', 'Gorge': '19833824743', 'Jordan': '18807317878', 'Curry': '15093488129', 'Wade': '19282937665' } # 使用键直接访问值 print(phone_book['mayun']) # 输出：13309283335这种方式是最简单直接的查询方法，你只需要使用字典的键作为索引，就可以直接获取对应的值。
-
使用
get()方法：phone_book = { 'mayun': '13309283335', 'zhaolong': '18989227822', 'zhangmin': '13382398921', 'Gorge': '19833824743', 'Jordan': '18807317878', 'Curry': '15093488129', 'Wade': '19282937665' } # 使用 get() 方法访问值 print(phone_book.get('mayun')) # 输出：13309283335get()方法接受一个键作为参数，返回对应键的值。与直接访问不同的是，如果键不存在于字典中，get()方法会返回None，而不是抛出 KeyError 异常。
无论是直接使用键访问值，还是使用 get() 方法，都能够很方便地查询字典中的值。
拓展 功能增加
好的，我们可以在之前的电话簿管理程序中加入一个功能，允许用户通过输入联系人的名字来查询其电话号码。下面是更新后的代码：
phone_book = {
'mayun': '13309283335',
'zhaolong': '18989227822',
'zhangmin': '13382398921',
'Gorge': '19833824743',
'Jordan': '18807317878',
'Curry': '15093488129',
'Wade': '19282937665'
}
def add_contact():
name = input("请输入联系人姓名：")
number = input("请输入联系人电话号码：")
phone_book[name] = number
print("已成功添加联系人：{} - {}".format(name, number))
def delete_contact():
name = input("请输入要删除的联系人姓名：")
if name in phone_book:
del phone_book[name]
print("已成功删除联系人：{}".format(name))
else:
print("未找到联系人：{}".format(name))
def show_phone_book():
print("电话簿内容：")
for name, number in phone_book.items():
print("{} - {}".format(name, number))
def search_contact():
name = input("请输入要查找的联系人姓名：")
if name in phone_book:
print("{} 的电话号码是：{}".format(name, phone_book[name]))
else:
print("未找到联系人：{}".format(name))
while True:
print("\n电话簿操作菜单：")
print("1. 添加联系人")
print("2. 删除联系人")
print("3. 查找联系人")
print("4. 退出程序")
choice = input("请选择操作（输入对应数字）：")
if choice == '1':
add_contact()
elif choice == '2':
delete_contact()
elif choice == '3':
search_contact()
elif choice == '4':
print("程序已退出。")
break
else:
print("无效的选项，请重新输入。")
在这个更新后的程序中，我们添加了一个名为 search_contact() 的新函数。当用户选择查找联系人操作时，程序会提示用户输入联系人的名字，然后根据输入的名字在电话簿中查找对应的电话号码，并将结果显示给用户。
2. 代码
依据问题分析部分，我们可以书写完整代码，但是根据题目的详细要求，我们要做出修改
1. 题目详细部分
输入输出要求
【输入形式】
人名，是一个字符串。
【输出形式】
电话号码。如果该人不存在，返回"not found"
【样例输入】
mayun
【样例输出】
13309283335
输入输出示例
| 输入 | 输出 | |
|---|---|---|
| 示例 1 | Curry | 15093488129 |
2. 最终提交代码
phone_book = {
'mayun': '13309283335',
'zhaolong': '18989227822',
'zhangmin': '13382398921',
'Gorge': '19833824743',
'Jordan': '18807317878',
'Curry': '15093488129',
'Wade': '19282937665'
}
def search_contact(name):
if name in phone_book:
return phone_book[name]
else:
return "not found"
# 获取用户输入
name = input()
# 调用函数进行查询并输出结果
print(search_contact(name))
好的这个题目就结束了，看第二题
2. 成绩统计(列表版)
问题描述
输入一组学生成绩，存放于列表中，计算所有学生的平均分和前三名的成绩。
1. 问题分析
1. 输入输出分析
输入: 一组学生成绩
输出: 学生平均分和前三名成绩
约束 :学生成绩存储在列表
2. 需求分析: 读取键盘输入内容，存储在列表中，并计算平均分，和找出前三名
3. 所需知识: python读取键盘内容的数据类型，如何转化为列表，列表如何计算平均值，列表如何排序并输出成绩前三最大数
1. python读取键盘输入内容(input)的数据类型
在Python中，input() 函数接受用户输入，并将输入的内容作为字符串返回。无论用户输入的是数字、字母、符号还是其他内容，input() 函数都会将其作为字符串类型返回。
因此，无论用户输入的内容是什么，我们都会得到一个字符串。例如，如果用户输入了数字 "90 80 70"，那么 input() 函数将返回字符串 "90 80 70"；如果用户输入了字母 "abc def"，那么 input() 函数将返回字符串 "abc def"。
在我们的程序中，我们可以使用 input() 函数来接收用户输入的成绩，然后将输入的字符串按照空格分割成一个列表。接下来，我们可以将列表中的字符串成绩转换为整数类型，以便进行数值计算。
2. 将字符串转化为列表的方法
在Python中，有几种常用的方法可以将字符串转换为列表：
1. 使用 split() 方法：
split() 方法可以根据指定的分隔符将字符串分割成多个子串，并返回一个包含所有子串的列表。
# 示例
string = "apple banana cherry"
lst = string.split() # 使用空格分割字符串，默认按空格分割
print(lst) # 输出：['apple', 'banana', 'cherry']
2. 使用列表推导式：
如果字符串的内容符合某种规律（例如每个单词之间用空格分隔），我们可以使用列表推导式将字符串拆分为列表。
# 示例
string = "apple banana cherry"
lst = [word for word in string.split()] # 使用列表推导式将字符串按空格分割成列表
print(lst) # 输出：['apple', 'banana', 'cherry']
3. 使用 list() 函数：
list() 函数可以将字符串中的每个字符分割成单独的字符，并返回一个包含所有字符的列表。
# 示例
string = "apple"
lst = list(string) # 将字符串拆分为单个字符的列表
print(lst) # 输出：['a', 'p', 'p', 'l', 'e']
4. 使用正则表达式：
如果需要更复杂的分割规则，可以使用 Python 的 re 模块中的正则表达式功能。
import re
# 示例：按照逗号和空格分割字符串
string = "apple, banana, cherry"
lst = re.split(r',\s*', string)
print(lst) # 输出：['apple', 'banana', 'cherry']
这些方法中，最常用的是 split() 方法和列表推导式，它们适用于大多数情况下的字符串拆分需求。
3. 列表如何计算平均值
还有一件很重要的事情 字符串虽然改成列表了，但列表里仍然是字符串
我们需要把他们转化为整数
scores = [int(scores) for score in scores] #将字符串列表转换为整数列表
要计算列表中所有元素的平均值，可以按照以下步骤进行：
- 将列表中所有元素相加，得到总和。
- 将总和除以列表的长度，得到平均值。
下面是一个示例代码：
# 定义一个包含成绩的列表
scores = [90, 85, 88, 92, 95]
# 计算总和
total = sum(scores)
# 计算平均值
average = total / len(scores)
# 输出结果
print("平均值为:", average)
这段代码首先定义了一个包含成绩的列表 scores，然后使用 sum() 函数计算列表中所有成绩的总和，将结果存储在变量 total 中。接着，使用 len() 函数获取列表的长度，即学生人数，然后将总和除以学生人数，得到平均值，并将结果存储在变量 average 中。最后，使用 print() 函数输出平均值。
在实际应用中，只需将以上代码中的 scores 替换为所拥有的成绩列表，即可计算该列表中所有元素的平均值。
拓展：获取列表中对象的个数 : len( )
len() 是 Python 内置函数之一，用于获取对象的长度或元素个数。它可以应用于各种数据类型，包括字符串、列表、元组、字典等。
使用方法
语法：len(object)
object：要获取长度的对象。
示例
- 获取字符串的长度：
string = "Hello, world!"
length = len(string)
print("字符串的长度为：", length) # 输出：13
- 获取列表的长度：
my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print("列表的长度为：", length) # 输出：5
- 获取元组的长度：
my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print("元组的长度为：", length) # 输出：5
- 获取字典的长度（即键值对的数量）：
my_dict = {"a": 1, "b": 2, "c": 3}
length = len(my_dict)
print("字典的长度为：", length) # 输出：3
注意事项
-
对于字符串，
len()返回字符串中字符的个数。 -
对于列表、元组和字典，
**len()返回它们包含的元素的个数**（即列表和元组中元素的数量，字典中键值对的数量）。 -
如果传入的对象是空的，
len()将返回 0。 -
如果传入的对象是一个自定义类的实例，可以在类中定义
__len__()方法来自定义长度的计算方式。
4. 列表如何排序
在Python中，可以使用 sorted() 函数或列表对象的 sort() 方法对列表进行排序。
- 使用
sorted()函数：sorted()函数可以接受一个可迭代对象（如列表）作为参数，并返回一个新的已排序的列表，而不修改原始列表。
# 示例：使用 sorted() 函数对列表进行排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
- 使用列表对象的
sort()方法：sort()方法会就地修改列表对象，将其排序。
# 示例：使用 sort() 方法对列表进行排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print(numbers) # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
无论使用 sorted() 函数还是 sort() 方法，都可以实现对列表的排序。如果需要保留原始列表，可以使用 sorted() 函数；如果希望就地修改原始列表，可以使用 sort() 方法。
5. 获取列表中确定位置的值
要获取列表中特定位置的值，你可以使用索引。在 Python 中，列表的索引从 0 开始，因此第一个元素的索引为 0，第二个元素的索引为 1，依此类推。你可以通过将索引放在列表名称后的方括号内来访问列表中的元素。下面是一个示例：
my_list = [10, 20, 30, 40, 50]
# 获取第一个元素（索引为0）
first_element = my_list[0]
print("第一个元素：", first_element) # 输出：10
# 获取第三个元素（索引为2）
third_element = my_list[2]
print("第三个元素：", third_element) # 输出：30
如果你想获取列表中的最后一个元素，可以使用负数索引 -1。负数索引从列表的末尾开始，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。例如：
my_list = [10, 20, 30, 40, 50]
# 获取最后一个元素
last_element = my_list[-1]
print("最后一个元素：", last_element) # 输出：50
# 获取倒数第三个元素
third_from_last_element = my_list[-3]
print("倒数第三个元素：", third_from_last_element) # 输出：30
使用索引，你可以方便地访问列表中特定位置的值。
4. 书写代码
现在我们开始书写代码，
首先python读取键盘输入内容
scores = input()#用scores来接受input()的返回值此时scores的数据类型为字符串
然后我们把字符串转化为列表，再传递给scores，因为数据简单，我们选择split()方法来转换
scores = scores.split()#split()将空格中的字符串变为列表的元素
字符串虽然改成列表了，但列表里仍然是字符串
我们需要把他们转化为整数
scores = [int(score) for score in scores] #将字符串列表转换为整数列表
然后计算平均值，列表内元素相加再除以列表的长度
total = sum(scores)#使用sum()方法计算总和
average = total/len(scores)#使用len()方法获取total列表的长度
因为要求输出的保留一位小数，所以
print("{:.1f}".format(average))
最后对列表排序，前三名输出
sorted_scores = sorted(scores)#使用sorted()函数给整数列表排序
first_score = sorted_scores[-1]
second_score = sorted_scores[-2]
third_score = sorted_scores[-3]
因为要求输出的之间要空格在一行
所以
print(str(first_score)+" "+str(second_score)+" "+str(third_score)+" ")
2. 代码
所有代码功能已经实现，现在开始完整代码
scores = input()#用scores来接受input()的返回值此时scores的数据类型为字符串
scores = scores.split()#字符串转化为字符串列表
scores = [int(score) for score in scores] #将字符串列表转换为整数列表
total = sum(scores)#使用sum()方法计算总和
average = total/len(scores)#使用len()方法获取total列表的长度
sorted_scores = sorted(scores) #使用sorted()函数给整数列表排序
first_score = sorted_scores[-1]
second_score = sorted_scores[-2]
third_score = sorted_scores[-3]
print("{:.1f}".format(average))
print(str(first_score)+" "+str(second_score)+" "+str(third_score)+" ")
到这里初级方法写这个代码就完成了，当然还有高级方法完成以下
#主程序
def str_to_list(scores):#字符串转化为整数列表
scores = scores.split()#字符串转化为字符串列表
scores = [int(score) for score in scores] #将字符串列表转换为整数列表
return scores
def calculate_scores(scores):#封装功能方法
total = sum(scores)#使用sum()方法计算总和
average = total/len(scores)#使用len()方法获取total列表的长度
sorted_scores = sorted(scores) #使用sorted()函数给整数列表排序
first_score = sorted_scores[-1]
second_score = sorted_scores[-2]
third_score = sorted_scores[-3]
return average,first_score,second_score,third_score
scores = input()#用scores来接受input()的返回值此时scores的数据类型为字符串
scores = str_to_list(scores)
average,first_score,second_score,third_score=calculate_scores(scores)
print("{:.1f}".format(average))
print(str(first_score)+" "+str(second_score)+" "+str(third_score)+" ")
虽然暂时达不到，但是思想可以借鉴，每一个功能就封装为一个方法
#主程序
def str_to_list(scores):#字符串转化为整数列表
scores = scores.split()#字符串转化为字符串列表
scores = [int(score) for score in scores] #将字符串列表转换为整数列表
return scores
def calculate_scores(scores):#封装功能方法
total = sum(scores)#使用sum()方法计算总和
average = total/len(scores)#使用len()方法获取total列表的长度
sorted_scores = sorted(scores) #使用sorted()函数给整数列表排序
first_score = sorted_scores[-1]
second_score = sorted_scores[-2]
third_score = sorted_scores[-3]
return sorted_scores,first_score,second_score,third_score
scores = input()#用scores来接受input()的返回值此时scores的数据类型为字符串
scores = str_to_list(scores)
sorted_scores,first_score,second_score,third_score=calculate_scores(scores)
print("{:.1f}".format(average))
print(str(first_score)+" "+str(second_score)+" "+str(third_score)+" ")
3. 补考几科（列表）
问题描述
【问题描述】输入一个学生5门课程的成绩，存放于列表中，输出平均分和要补考的门数。
1.问题分析
1. 输入输出分析
输入： 每行输入每门课程的成绩(一共5门)
输出： 平均分和要补考的门数 两行
2. 需求分析 : 读取每行输入每门课程的成绩，如何转化为列表，计算平均分和 要补考的门数
3. 所需知识 : python如何把每行输入的成绩转化为列表，列表计算平均分，列表筛选出小于60分的门数。
1. python 多行输入存储
在 Python 中，你可以使用循环来逐行读取多行输入，并将每一行存储在一个列表中。下面是一个示例代码，演示了如何实现这一功能：
# 创建一个空列表来存储多行输入
lines = []
# 使用循环逐行读取输入，直到输入结束（输入空行为结束标志）
while True:
line = input("请输入一行内容（输入空行结束）：")
if line == "":
break # 如果输入为空行，退出循环
lines.append(line) # 将输入的行添加到列表中
# 输出存储的多行输入
print("你输入的内容是：")
for line in lines:
print(line)
这段代码会提示用户逐行输入内容，直到输入空行为止。用户每输入一行内容，都会将该行添加到列表 lines 中。最后，程序会输出存储的多行输入内容。
2. 列表计算平均分
之前说过了，不再说
3. 列表筛选出小于60分的门数
在 Python 中，可以使用列表推导式或 filter() 函数来筛选符合条件的数据。
使用列表推导式
列表推导式是一种简洁的方法，用于根据条件从一个列表中生成一个新的列表。语法如下：
new_list = [expression for item in iterable if condition]
其中：
expression是一个表达式，用于定义新列表中的元素。item是可迭代对象中的元素。iterable是一个可迭代对象，例如列表、元组、集合等。condition是一个条件，只有当条件为True时，item才会被包含在新列表中。
示例：
# 从列表中筛选出所有大于等于5的元素
old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = [x for x in old_list if x >= 5]
print(new_list) # 输出：[5, 6, 7, 8, 9, 10]
使用 filter() 函数
filter() 函数用于过滤可迭代对象中的元素，返回一个迭代器，其中包含使函数返回 True 的元素。语法如下：
filter(function, iterable)
其中：
function是一个函数，用于定义过滤条件。iterable是一个可迭代对象，例如列表、元组、集合等。
示例：
# 定义一个函数，用于判断元素是否大于等于5
def greater_than_five(x):
return x >= 5
# 使用 filter() 函数筛选符合条件的元素
old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = list(filter(greater_than_five, old_list))
print(new_list) # 输出：[5, 6, 7, 8, 9, 10]
无论使用列表推导式还是 filter() 函数，都可以实现对列表中符合条件的元素进行筛选。选择哪种方法取决于个人偏好和具体情况。
4. 书写代码
- 首先读取每行输入的成绩用之前提到的python多行输入存储
# 创建一个空列表来存储多行输入
scores = []
# 使用循环逐行读取输入，直到输入结束（输入空行为结束标志）
while True:
score = input()
if score == "":
break # 如果输入为空行，退出循环
scores.append(score) # 将输入的行添加到列表中
- 将字符串列表转化为整数列表
scores = [int(scores) for score in scores] #将字符串列表转换为整数列表
- 列表计算平均分
total = sum(scores)#sum()计算和
average = total/len(scores)#len()计算长度
-
列表筛选出小于60分的门数
# 筛选小于60分的方法 def smaller_than_60(x): return x < 60 # 使用filter()函数筛选符合条件的元素 retaken_scores = list(filter(smaller_than_60,scores) #计算要补考的门数 retaken_number = len(scores)
2. 代码
step_by_step 错误的
scores = []
while True : # 循环没有条件,从里面阻止
score = input()# 输入赋值给score
if score == "":#如果为空，跳出循环
break
scores.append(score) #列表的append()方法用于添加列表的内容
# 多行输入已经到字符串列表
# 现在由字符串列表转为 整数列表
scores = [int(score) for score in scores]
# 现在开始计算平均分
total = sum(scores)
average = total /len(scores)
#最后计算要补考的科目
#首先定义一个补考函数
def smaller_than_60(x):
return x < 60
# 用filter()函数筛选可迭代对象的元素
retaken_scores = list(filter(smaller_than_60,scores))
retaken_number = len(retaken_scores)
print(average)
print(retaken_number)
功能成方法
# python123 35 题 T3
# 多行输入已经转换字符串列表方法
def input_to_list():
for _ in range(5):
score = input()# 输入赋值给score
scores.append(score) #列表的append()方法用于添加列表的内容
return scores
#由字符串列表转为 整数列表
def strlist_to_intlist(scores):
scores = [int(score) for score in scores]
return scores
# 求平均数
def average_score(scores):
total = sum(scores)
average = total / len(scores)
return average
# 补考函数
def smaller_than_60(x):
return x < 60
def retaken_number(scores):
# 用filter()函数筛选可迭代对象的元素
retaken_scores = list(filter(smaller_than_60,scores))
retaken_number = len(retaken_scores)
return retaken_number
scores = []
scores = input_to_list()
scores = strlist_to_intlist(scores)
average = average_score(scores)
retaken_number = retaken_number(scores)
print(average)
print(retaken_number)
4. 课程及其编码保存为字典
问题描述
描述
按以下格式输入课程及编码的字典，然后编写代码完成如下功能：
（1）向字典中添加键值对"chemist":205。
（2）修改"math"对应的值为 201。
（3）用pop方法删除"biology"对应的键值对（若不存在该键，则返回“not exist"）。
（4）并按照键的升序打印字典 的全部信息，参考格式如下（注意，其中冒号为英文冒号，逐行打印）
1. 问题分析
1. 输入输出分析
输入： 课程和编码的字典
{“math”:200, “chinese”:202, “english”:203}
输出：按照键的升序打印字典 的全部信息
205:chemist
202:chinese
203:english
201:math
（注意，其中冒号为英文冒号，逐行打印）
2. 需求分析: 输入格式存储为字典，向字典中添加键值对，修改其中的键值对，删除其中的键值对，排序字典的键值对并输出
3. 所需知识: python 如何将输入格式存储为字典， 字典的增删改查操作如何实现，字典排序如何实现
1. python 如何将输入 格式存储为字典
输入的格式是一个字符串，表示一个字典，其中键值对以键值对应的字符串形式给出，键值对之间用逗号分隔，键与值之间用英文冒号分隔。这种格式可以通过 eval() 函数来转换为字典。
下面是一个示例代码：
input_str = '{"math":200, "chinese":202, "english":203}'
course_dict = eval(input_str)
print(course_dict)
运行这段代码，会输出：
{'math': 200, 'chinese': 202, 'english': 203}
这样，输入的字符串就被转换成了一个字典。注意，使用 eval() 函数时需要确保输入的字符串是安全的，不包含任何恶意代码，否则可能存在安全风险。
2. 字典的增删改查操作如何实现
字典的增删改查操作如下：
1. 添加键值对：
使用字典的索引赋值操作或者 update() 方法来添加键值对。
2. 修改键值对：
使用字典的索引赋值操作来修改键对应的值。
3. 删除键值对：
使用 del 关键字或者 pop() 方法来删除键值对。
4. 查询键值对：
使用键来索引字典的值，或者使用 get() 方法来获取键对应的值，以避免键不存在时出现错误。
下面是具体的实现示例：
# 定义初始字典
course_dict = {'math': 200, 'chinese': 202, 'english': 203}
# 添加键值对
course_dict['chemist'] = 205
print("添加键值对后的字典：", course_dict)
# 修改键值对
course_dict['math'] = 201
print("修改键值对后的字典：", course_dict)
# 删除键值对
deleted_value = course_dict.pop('biology', 'not exist')
print("删除键值对后的字典：", course_dict)
print("删除的值（若键不存在则返回）：", deleted_value)
# 查询键值对
course_english = course_dict['english']
print("英语成绩：", course_english)
# 更安全的查询方式
course_biology = course_dict.get('biology', 'not exist')
print("生物成绩（安全查询）：", course_biology)
运行以上代码，会得到如下输出：
添加键值对后的字典： {'math': 200, 'chinese': 202, 'english': 203, 'chemist': 205}
修改键值对后的字典： {'math': 201, 'chinese': 202, 'english': 203, 'chemist': 205}
删除键值对后的字典： {'math': 201, 'chinese': 202, 'english': 203, 'chemist': 205}
删除的值（若键不存在则返回）： not exist
英语成绩： 203
生物成绩（安全查询）： not exist
这样，你就可以实现字典的增删改查操作了。
3.字典排序如何实现
字典是无序的数据结构，无法直接对字典进行排序。但是，我们可以对字典的键或值进行排序，然后再根据排好序的键或值来访问字典的键值对。具体做法是使用 sorted() 函数或者 collections 模块中的 OrderedDict 类。
-
**对键进行排序：**使用
sorted()函数对字典的键进行排序，然后遍历排序后的键，依次访问字典的键值对。 -
**对值进行排序：**如果需要按照值进行排序，可以使用
sorted()函数结合key参数，指定排序的依据为字典的值。
下面是具体的实现示例：
# 定义初始字典
course_dict = {'math': 200, 'chinese': 202, 'english': 203, 'chemist': 205}
# 按照键进行排序并打印
sorted_keys = sorted(course_dict.keys())
print("按照键升序排序后的字典：")
for key in sorted_keys:
print("{}:{}".format(key, course_dict[key]))
# 按照值进行排序并打印
sorted_items = sorted(course_dict.items(), key=lambda x: x[1])
print("按照值升序排序后的字典：")
for key, value in sorted_items:
print("{}:{}".format(key, value))
运行以上代码，会得到按照键或值升序排序后的字典输出。
5. 拓展: 使用update() 完成字典的增加操作
update() 方法用于将一个字典中的键值对添加到另一个字典中，或者用一个字典中的键值对更新另一个字典中相同键的值。具体用法如下：
# 定义两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
# 使用 update() 方法将 dict2 的键值对添加到 dict1 中
dict1.update(dict2)
# 输出更新后的 dict1
print(dict1)
运行以上代码，会输出：
{'a': 1, 'b': 3, 'c': 4}
可以看到，update() 方法将 dict2 的键值对添加到 dict1 中，并更新了相同键的值。
6. 拓展: 使用 pop() 方法删除字典中指定键的键值对
pop() 方法用于删除字典中指定键的键值对，并返回对应的值。具体用法如下：
# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 使用 pop() 方法删除指定键的键值对，并返回对应的值
value = my_dict.pop('b')
# 输出删除后的字典和返回的值
print("删除后的字典：", my_dict)
print("删除的值：", value)
运行以上代码，会输出：
删除后的字典： {'a': 1, 'c': 3}
删除的值： 2
可以看到，pop('b') 删除了字典中键为 ‘b’ 的键值对，并返回了对应的值。如果指定的键不存在，则 pop() 方法会引发 KeyError 异常，但可以提供一个默认值，以避免异常，例如 pop('z', None) 将返回 None 而不会引发异常。
4.书写代码
python输入的格式存储为字典
input_str = input() #获取键盘输入
course_dict = eval(input_str) #使用eval函数转化
实现向字典中添加键值对"chemist":205。
# 直接使用字典的索引赋值操作
course_dict[chemist] = 205
# 使用update()方法添加键值对
course_dict_add = {'chemist':205}
course_dict.update(course_dict_add)
实现修改"math" 对应的值为201
#使用字典的索引赋值操作来修改键对应的值。
course_dict[math] = 201
实现用pop方法删除"biology"对应的键值对(若不存在该键，则返回"not exist")
#因为明确用pop方法，我们必须使用pop()
# pop(x,y)如果有x就删除，没有就返回y
deleted_value = course_dict.pop('biology','not exist')
实现按照键的升序打印字典的全部信息
#键的升序就是按照 科目的升序
sorted_keys = sorted(course_dict.keys())
#键是key 值是item
#打印全部
for key in sorted_keys:
print("{}:{}".format(key, course_dict[key]))
2. 代码
最终书写完整代码
def str_to_dict(x):
y = eval(x)
return y
def add_dict(x1):
x2 = {'chemist':205}
x1.update(x2)
return x1
input_str = input()
course_dict = str_to_dict(input_str)
course_dict = add_dict(course_dict)
course_dict['math'] = 201
deleted_value = course_dict.pop('biology','not exist')
sorted_keys = sorted(course_dict.keys())
for key in sorted_keys:
print("{}:{}".format(key, course_dict[key]))
优化代码
你的代码基本实现了题目要求，但是我注意到了一些可以改进的地方：
-
**eval() 函数的使用：**虽然
eval()函数能够将字符串转换为字典，但是它具有一定的安全风险，因为它会执行字符串中的任何有效 Python 表达式。在这种情况下，如果输入的字符串不符合字典的格式，可能会引发异常。更安全的方法是使用json模块来解析 JSON 格式的字符串。 -
**函数命名：**函数命名应当尽量清晰明了，可以更具体地描述函数的功能。
-
**全局变量和局部变量的使用：**尽量避免在函数中直接修改全局变量，而应该将函数的结果作为返回值返回，在主程序中接收并处理。
下面是一个改进后的示例代码：
import json
def str_to_dict(input_str):
# 使用 json.loads() 方法将输入的字符串转换为字典
return json.loads(input_str) #json更加安全可靠
def add_chemist(course_dict):
# 添加化学成绩
course_dict['chemist'] = 205
return course_dict
# 获取用户输入
input_str = input("请输入课程及编码的字典：")
# 将字符串转换为字典
course_dict = str_to_dict(input_str)
# 添加化学成绩
course_dict = add_chemist(course_dict)
# 修改数学成绩
course_dict['math'] = 201
# 删除生物成绩
deleted_value = course_dict.pop('biology', 'not exist')
# 按键升序打印字典
sorted_keys = sorted(course_dict.keys())
for key in sorted_keys:
print("{}:{}".format(key, course_dict[key]))
这样，你的代码更加清晰易读，并且减少了使用 eval() 函数带来的安全风险。
输出要求键值对变换
按照键的升序输出字典的键值对，每行格式为"值:键"。可以在遍历字典时，先将键值对的值和键格式化成你想要的形式输出。下面是相应的修改：
import json
def str_to_dict(input_str):
# 使用 json.loads() 方法将输入的字符串转换为字典
return json.loads(input_str)
def add_chemist(course_dict):
# 添加化学成绩
course_dict['chemist'] = 205
return course_dict
# 获取用户输入
input_str = input("请输入课程及编码的字典：")
# 将字符串转换为字典
course_dict = str_to_dict(input_str)
# 添加化学成绩
course_dict = add_chemist(course_dict)
# 修改数学成绩
course_dict['math'] = 201
# 删除生物成绩
deleted_value = course_dict.pop('biology', 'not exist')
# 按键升序打印字典
sorted_keys = sorted(course_dict.keys())
for key in sorted_keys:
print("{}:{}".format(course_dict[key], key))
![论文分享[cvpr2018]Non-local Neural Networks非局部神经网络](https://img-blog.csdnimg.cn/direct/690a833bf8324c1f943891fa2c0c00d4.png)
