python基础 面向练习学习python1

1. 电话查询

问题描述

定义一个电话簿，里头设置以下联系人：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘mayun’:‘13309283335’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘zhaolong’:‘18989227822’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘zhangmin’:‘13382398921’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘Gorge’:‘19833824743’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘Jordan’:‘18807317878’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘Curry’:‘15093488129’,‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

‘Wade’:'19282937665’‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

现在输入人名，查询他的号码。

1. 问题分析

1. 输入输出分析

输入：人名
输出：电话号码

2. 需求分析：将题目的数据存储并查询

我们要解决几个问题，
数据的存储，数据的查询，
首先如何存储数据？
输入人名，输出电话号码，
人名相当于是地址标记，电话号码是数据，
但是不是，如果输入电话号码查找人名该怎么办呢？
所以，他们应该是同等的，
两个数据链接起来，输入一个可以查找其他的数据就像对象的封装一样，
python有哪个数据类型能完成我的想法？
但是，我们要先知道python里面有哪些数据类型

2. 所需知识： python 数据存储的类型

在Python中，有许多种不同的数据类型，每种类型都有其特定的用途和适用场景。下面是一些常见的数据类型以及它们的简要介绍：

1. 整数（int）：用于表示整数值，如 -5, 0, 100 等。

2. 浮点数（float）：用于表示带有小数部分的数值，如 3.14, -0.001, 2.71828 等。

3. 字符串（str）：用于表示文本数据，由单引号 ' 或双引号 " 包裹，如 'hello', "world", '123' 等。

4. 列表（list）：用于存储一系列有序的元素，可以包含不同类型的数据，如 [1, 2, 3], ['apple', 'banana', 'orange'] 等。

5. 元组（tuple）：类似于列表，但是元组是不可变的，即不能修改其中的元素，如 (1, 2, 3), ('a', 'b', 'c') 等。

6. 字典（dict）：用于存储键值对，每个键都与一个值相关联，键必须是唯一的，如 {'name': 'John', 'age': 30, 'city': 'New York'} 等。

7. 集合（set）：用于存储无序、不重复的元素，主要用于去重和集合运算，如 {1, 2, 3}, {2, 2, 3, 3, 4, 4} 等。

8. 布尔值（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("程序已退出。")breakelse:#保证程序的健壮性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] = numberprint("已成功添加联系人：{} - {}".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("程序已退出。")breakelse:print("无效的选项，请重新输入。")

在这个版本中，我们添加了一个新的函数 show_phone_book()，它会遍历电话簿中的每个联系人，并打印出他们的名字和电话号码。在每次用户进行操作之前，我们会先调用这个函数来显示电话簿的内容，这样用户就能清楚地知道当前电话簿中包含哪些联系人信息。

---

5. 回到数据查询 代码

刚刚我们解决了数据存储的问题现在我们面临数据查询的问题，那么python是如何查询字典呢？

在Python中，你可以使用字典的键来快速查询对应的值。字典内部实现了一种高效的数据结构，使得根据键来查找对应的值具有很高的效率，平均时间复杂度为 O(1)。

你可以通过以下两种方式来查询字典中的值：

1. 使用键直接访问值：

   phone_book = {'mayun': '13309283335','zhaolong': '18989227822','zhangmin': '13382398921','Gorge': '19833824743','Jordan': '18807317878','Curry': '15093488129','Wade': '19282937665'
   }# 使用键直接访问值
   print(phone_book['mayun'])  # 输出：13309283335
   

   这种方式是最简单直接的查询方法，你只需要使用字典的键作为索引，就可以直接获取对应的值。

2. 使用 get() 方法：

   phone_book = {'mayun': '13309283335','zhaolong': '18989227822','zhangmin': '13382398921','Gorge': '19833824743','Jordan': '18807317878','Curry': '15093488129','Wade': '19282937665'
   }# 使用 get() 方法访问值
   print(phone_book.get('mayun'))  # 输出：13309283335
   

   get() 方法接受一个键作为参数，返回对应键的值。与直接访问不同的是，如果键不存在于字典中，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] = numberprint("已成功添加联系人：{} - {}".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("程序已退出。")breakelse: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] #将字符串列表转换为整数列表

要计算列表中所有元素的平均值，可以按照以下步骤进行：

1. 将列表中所有元素相加，得到总和。
2. 将总和除以列表的长度，得到平均值。

下面是一个示例代码：

# 定义一个包含成绩的列表
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：要获取长度的对象。

示例

1. 获取字符串的长度：

string = "Hello, world!"
length = len(string)
print("字符串的长度为：", length)  # 输出：13

2. 获取列表的长度：

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print("列表的长度为：", length)  # 输出：5

3. 获取元组的长度：

my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print("元组的长度为：", length)  # 输出：5

4. 获取字典的长度（即键值对的数量）：

my_dict = {"a": 1, "b": 2, "c": 3}
length = len(my_dict)
print("字典的长度为：", length)  # 输出：3

注意事项

• 对于字符串，len() 返回字符串中字符的个数。

• 对于列表、元组和字典，**len() 返回它们包含的元素的个数**（即列表和元组中元素的数量，字典中键值对的数量）。

• 如果传入的对象是空的，len() 将返回 0。

• 如果传入的对象是一个自定义类的实例，可以在类中定义 __len__() 方法来自定义长度的计算方式。

4. 列表如何排序

在Python中，可以使用 sorted() 函数或列表对象的 sort() 方法对列表进行排序。

1. 使用 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]

2. 使用列表对象的 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 scoresdef 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_scorescores = 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 scoresdef 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_scorescores = 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. 书写代码

1. 首先读取每行输入的成绩用之前提到的python多行输入存储

# 创建一个空列表来存储多行输入
scores = []# 使用循环逐行读取输入，直到输入结束（输入空行为结束标志）
while True:score = input()if score == "":break  # 如果输入为空行，退出循环scores.append(score)  # 将输入的行添加到列表中

2. 将字符串列表转化为整数列表

scores = [int(scores) for score in scores] #将字符串列表转换为整数列表

3. 列表计算平均分

total = sum(scores)#sum()计算和
average = total/len(scores)#len()计算长度

4. 列表筛选出小于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()# 输入赋值给scoreif score == "":#如果为空，跳出循环breakscores.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()# 输入赋值给scorescores.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 < 60def retaken_number(scores):# 用filter()函数筛选可迭代对象的元素retaken_scores = list(filter(smaller_than_60,scores))retaken_number = len(retaken_scores)return retaken_numberscores = []
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 类。

1. **对键进行排序：**使用 sorted() 函数对字典的键进行排序，然后遍历排序后的键，依次访问字典的键值对。

2. **对值进行排序：**如果需要按照值进行排序，可以使用 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]))

优化代码

你的代码基本实现了题目要求，但是我注意到了一些可以改进的地方：

1. **eval() 函数的使用：**虽然 eval() 函数能够将字符串转换为字典，但是它具有一定的安全风险，因为它会执行字符串中的任何有效 Python 表达式。在这种情况下，如果输入的字符串不符合字典的格式，可能会引发异常。更安全的方法是使用 json 模块来解析 JSON 格式的字符串。

2. **函数命名：**函数命名应当尽量清晰明了，可以更具体地描述函数的功能。

3. **全局变量和局部变量的使用：**尽量避免在函数中直接修改全局变量，而应该将函数的结果作为返回值返回，在主程序中接收并处理。

下面是一个改进后的示例代码：

import jsondef str_to_dict(input_str):# 使用 json.loads() 方法将输入的字符串转换为字典return json.loads(input_str) #json更加安全可靠def add_chemist(course_dict):# 添加化学成绩course_dict['chemist'] = 205return 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 jsondef str_to_dict(input_str):# 使用 json.loads() 方法将输入的字符串转换为字典return json.loads(input_str)def add_chemist(course_dict):# 添加化学成绩course_dict['chemist'] = 205return 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))