Python计算机二级大题

1.

键盘输入字符串s，按要求把s输出到屏幕，格式要求:宽度为30个字符，星号字符*填充，居中对齐。如果输入字符串超过30位，则全部输出。
例如:键盘输入字符串s为"Congratulations”，屏幕输出*******Congratulations*******

s = input("请输入一个字符串:")
print("{:*^30}".format(s))

解析：

这里使用了 Python 的字符串格式化功能。具体来说，"{:*^30}" 是一个格式化字符串，其中：

• * 表示要用星号 * 填充空白部分；

• ^ 表示要居中原字符串；

• 30 表示总宽度为 30 个字符。

• < 表示左对齐，即将填充字符放在右边。

• > 表示右对齐，即将填充字符放在左边。

• = 用于数字，表示将填充字符放在符号和数字之间。

然后，我们使用字符串的 format() 方法，将变量 s 插入到格式化字符串中，得到最终的输出结果，并使用 print() 函数将其输出到终端。

---

2.

根据斐波那契数列的定义，F(0)=0，F(1)=1,F(n)=F(-1)+F(n-2)(n>=2)，输出不大于50的序列元素。
例如:屏幕输出实例为:
0,1,1,2,3,...(略)

a, b = 0, 1
while a <= 50:
    print(a, end=',')
    a, b = b, a+b

解析：

首先，我们定义了变量 a 和 b，分别初始化为 0 和 1。然后，我们使用 while 循环来迭代，只要 a 的值小于或等于 50，就会一直执行循环体中的代码。

在循环体中，我们首先使用 print() 函数打印出当前的 a 值，并使用 end=',' 参数来指定在输出中以逗号结尾而不是默认的换行符。然后，我们使用多重赋值语句将 b 的值赋给 a，将 a+b 的值赋给 b，这样就可以更新 a 和 b 的值，以便下一次循环时使用。

最终，当 a 的值大于 50 时，循环停止。因此，输出的结果是斐波那契数列的前 50 个数字，以逗号分隔。

---

3.

键盘输入一句话，用jieba分词后，将切分的词组按照在原话中逆序输出到屏幕上，词组中间没有空格。示例如下:
输入:
我爱老师
输出:
老师爱我

import jieba
txt = input("请输入一段中文文本:")
ls = jieba.lcut(txt)
for i in ls[::-1]:
    print(i,end="")

解析：

input() 函数用来获取用户输入的一段中文文本，并将其存储在变量 txt 中。

jieba.lcut() 函数用来将文本进行分词，将分词结果存储在列表 ls 中。

lcut() 函数返回的是一个列表，其中每个元素都是分词后的一个词语。

最后，代码通过 for 循环遍历 ls 列表，将分词结果逆序输出。

[::-1] 表示从列表末尾开始，每次递减一个元素，即将列表逆序输出。

end="" 表示输出时不换行，即将所有词语输出在同一行

• jieba.lcut(txt) 是 jieba 库中的一个函数，它的作用是将输入的中文文本进行分词，返回一个列表，其中每个元素都是分词后的一个词语。

---

4.

使用turtle库的turtlefd0函数和turtle.seth0函数绘制一个边长为100的三角形

import turtle
for i in range(3):
    turtle.seth(i*120)
    turtle.fd(100)

解析：

1. import turtle：导入turtle模块，turtle是Python中一个强大的绘图库，可以用来绘制各种形状和图形。

2. for i in range(3): 使用for循环语句，循环3次，其中i的取值分别为0, 1, 2。

3. turtle.seth(i*120)：设置海龟的朝向，i的取值分别为0, 1, 2，所以分别设置海龟的朝向为0度、120度、240度。因为等边三角形的每个内角都是60度，所以这里每次设置海龟的朝向为120度。

4. turtle.fd(100)：让海龟向前移动100个像素，这里的像素是屏幕上的单位，向右为x轴正方向，向上为y轴正方向。

• "海龟"是指turtle模块中的一个绘图对象，可以理解为一个画笔，可以在屏幕上绘制各种形状和图形。海龟有一个初始位置和朝向，可以通过控制它的移动和旋转来绘制出复杂的图形。在turtle模块中，可以使用一系列函数来控制海龟的移动、旋转和绘制。

---

5.

键盘输入一组水果名称并以空格分隔，共一行。示例格式如下:苹果芒果草莓 芒果苹果草莓 芒果香芒果草莓
统计各类型的数量，从数量多到少的顺序输出类型及对应数量，以英文冒号分隔，每个类型行。输出结果保存在考生文件夹下，命名为“PY202.txt”。输出参考格式如下:
芒果:4
草莓:3
苹果:2
香: 1

# 打开一个名为 PY202.txt 的文件，以写入模式打开
fo = open("PY202.txt","w")

# 从用户输入中读取类型序列并将其分割成水果列表
txt = input("请输入类型序列: ")
fruits = txt.split(" ")

# 创建一个空字典
d = {}

# 遍历水果列表并将每个水果添加到字典中，如果水果已经在字典中，则将其数量加1
for fruit in fruits:
    d[fruit] = d.get(fruit,0) + 1

# 将字典转换为列表并按数量排序（从高到低）
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True)  

# 将每个水果及其数量写入文件中
for k in ls:
    fo.write("{}:{}\n".format(k[0], k[1]))

# 关闭文件
fo.close()

解析：

字典 d 来统计每个水果出现的次数。在 for 循环中，对于列表 fruits 中的每个水果，使用

d.get(fruit,0) 来获取该水果在字典 d 中的值，如果该水果不存在，则返回默认值 0。然后将该水果在字典中的值加 1，最后将结果存储回字典 d 中。

将字典 d 中的键值对转换为列表 ls，并按照每个键值对的值（即出现次数）从高到低排序。其中，list(d.items()) 将字典 d 中的键值对转换为列表，

ls.sort(key=lambda x:x[1], reverse=True) 使用 sort 方法对列表 ls 进行排序，

key=lambda x:x[1] 表示按照每个元素的第二个值（即出现次数）进行排序，

reverse=True 表示按照降序排列。

使用 for 循环遍历排好序的列表 ls，并将每个水果及其出现次数写入到文件 "PY202.txt" 中。其中，

k[0] 表示每个键值对中的键（即水果名称），

k[1] 表示每个键值对中的值（即出现次数），

fo.write("{}:{}\n".format(k[0], k[1])) 表示将水果名称和出现次数格式化为字符串，并写入到文件中。

---

6.

《卖火柴的小女孩》是丹麦童话故事作家安徒生的一篇童话故事，发表于1846年。主要讲了一个卖火柴的小女孩在富人阖家欢乐、举杯共庆的大年夜冻死在街头的故事。这里给出《卖火柴的小女孩》的一个网络版本文件，文件名为“小女孩.txt”。

问题1(5分):在PY301-1.py文件中修改代码，对“小女孩.txt文件进行字符频次统计，输出频次最高的中文字符(不包含标点符号)及其频次，将输出结果保存在考生文件夹下，命名为“PY301-1.txt”。字符与频次之间采用英文冒号"."分隔，示例格式如下:
的:83

问题2(5分):在PY301-2.p文件中修改代码，对“小女孩txt文件进行字符频次统计，按照频次由高到低，输出前10个频次最高的字符，不包含回车符，字符之间无间隔，连续输出，将输出结果保存在考生文件夹下，命名为PY301-2.txt”。示例格式如下:
的一...(后略，共10个字符)

问题3(10分):在PY301-3.py文件中修改代码，对"小女孩.txt"文件进行字符频次统计，将所有字符按照频次从高到低排序，字符包括中文、标点、英文等符号，但不包含空格和回车。将排序后的字符及频次输出到考生文件夹下，件名为“小女孩-频次排序.txt”。字符与频次之间采用英文冒号"."分隔，各字符之间采用英文逗号","分隔，参考CSV格式，最后无逗号，文件内部示例格式如下:
着:30那:29.火:29

# PY301-1.py
# 打开文件"小女孩.txt"，以只读模式打开
fi = open("小女孩.txt","r")
# 打开文件"PY301-1.txt"，以写入模式打开
fo = open("PY301-1.txt","w")
# 读取文件中的全部内容，保存到变量txt中
txt = fi.read()
# 创建一个空字典d，用来保存每个字符出现的次数
d = {}
# 定义一个字符串exclude，用来保存需要排除的字符
exclude = "，。！？、（）【】<>《》=：+-*—“”…"
# 遍历txt中的每个字符，统计每个字符出现的次数
for word in txt:
    # 如果字符在exclude中，则跳过不统计
    if word in exclude:
        continue
    # 如果字符不在exclude中，则将该字符的出现次数加1
    else:
        d[word] = d.get(word,0)+1
# 将字典d转换为一个列表ls，每个元素是一个元组，包含字符和出现次数两个值
ls = list(d.items())
# 对列表ls进行排序，按照元素的第二个值（出现次数）进行**降序排序**
ls.sort(key=lambda x:x[1],reverse=True)
# 将出现次数最高的字符和对应的出现次数写入到文件"PY301-1.txt"中
fo.write("{}:{}".format(ls[0][0],ls[0][1]))
# 关闭文件"PY301-1.txt"
fo.close()
# 关闭文件"小女孩.txt"
fi.close()

解析1：

d.get(word, 0) 会返回字典 d 中键为 word 的值，如果字典中没有该键，则返回默认值 0。然后，代码将返回的值加1，并将其作为新的值存储在字典中的 word 键下。

x:x[1]是一个lambda表达式，表示一个匿名函数，它的参数是一个元素x，返回值是该元素的第二个值x[1]。在这个例子中，x代表列表中的一个元素，如[1, 2]，[3, 4]等等。而x[1]则表示该元素的第二个值，如2，4等等。这个lambda表达式的作用是告诉sort方法按照每个元素的第二个值进行排序。

"{}:{}"是一个格式化字符串，其中{}表示占位符。这个字符串包含了两个占位符，分别用来表示字符和出现次数。例如，如果字符是'a'，出现次数是10，那么这个格式化字符串就变成了'a:10'。

format方法是一个字符串方法，用来将占位符替换为具体的值。在这个例子中，我们使用format方法将字符和出现次数替换到了格式化字符串中。

ls[0][0]表示出现次数最高的字符，ls[0][1]表示该字符出现的次数。因为ls已经按照出现次数进行了排序，所以ls[0]就是出现次数最高的元素。因此，这句代码的作用是将出现次数最高的字符及其出现次数写入到文件中。

write方法最后用来将字符串写入到文件中。在这个例子中，将出现次数最高的字符和对应的出现次数写入到文件"PY301-1.txt"中。

# 打开文件"小女孩.txt"，以只读模式打开
fi = open("小女孩.txt","r")
# 打开文件"PY301-2.txt"，以写入模式打开
fo = open("PY301-2.txt","w")
# 读取文件中的全部内容，保存到变量txt中
txt = fi.read()
# 创建一个空字典d，用来保存每个字符出现的次数
d = {}
# 遍历txt中的每个字符，统计每个字符出现的次数
for word in txt:
    # 如果字符是换行符，则跳过
    if word == "\n":
        continue
    # 如果字符在字典d中已经存在，则将该字符的出现次数加1
    if word in d:
        d[word] += 1
    # 如果字符在字典d中不存在，则将该字符添加到字典d中，并将出现次数初始化为1
    else:
        d[word] = 1
# 将字典d转换为一个列表ls，每个元素是一个元组，包含字符和出现次数两个值
ls = list(d.items())
# 对列表ls进行排序，按照元素的第二个值（出现次数）进行降序排序
ls.sort(key=lambda x:x[1], reverse=True)
# 将出现次数最高的前10个字符写入到文件"PY301-2.txt"中
for i in range(10):
    fo.write(ls[i][0])
# 关闭文件"小女孩.txt"
fi.close()
# 关闭文件"PY301-2.txt"
fo.close()

解析2:

key=lambda x:x[1] 是一个 lambda 函数，它接受一个元组 x 并返回它的第二个元素 x[1]。这个函数被用作排序的关键字。通过使用每个元组的第二个元素作为关键字，我们告诉 Python 按照每种水果的数量来排序。

reverse=True 指定我们要按照降序排列列表。如果不包含这个参数，列表将默认按照升序排列。

range(10) 会生成一个从0到9的整数序列，循环变量 i 会依次取到这个序列中的每个整数。

write(ls[i][0])是指在每次循环中，代码会将 ls 列表中第 i 个元组的第一个元素（也就是水果的名称）写入文件中。

# 以只读模式打开名为 "小女孩.txt" 的文件
fi = open("小女孩.txt","r")

# 以写入模式打开名为 "PY301-2.txt" 的文件
fo = open("PY301-2.txt","w")

# 读取文件中的文本内容
txt = fi.read()

# 创建一个空字典
d = {}

# 遍历文本中的每个字符并将其添加到字典中，如果字符已经在字典中，则将其数量加1
for word in txt:
    d[word] = d.get(word, 0) + 1

# 删除字典中的空格和换行符
del d[" "]
del d["\n"]

# 将字典转换为列表
ls = list(d.items())

# 按照值（也就是词频）从大到小排序
ls.sort(key=lambda x:x[1], reverse=True)

# 将列表中的每个元素转换为字符串，格式为 "字符:词频"
for i in range(len(ls)):
    ls[i] = "{}:{}".format(ls[i][0],ls[i][1])

# 将列表中的所有元素用逗号连接成一个字符串，并将其写入文件中
fo.write(",".join(ls))

# 关闭文件
fi.close()
fo.close()

解析3：

",".join(ls) 会将列表 ls 中的所有元素用逗号连接成一个字符串，得到一个新的字符串。然后，代码将这个新字符串写入文件中，以保存每个字符及其出现次数的信息。

---

7.

随机选择一个手机品牌屏幕输出。

# 导入 random 模块
import random

# 创建一个包含多个品牌名称的列表
brandlist = ['三星','苹果','vivo','OPPO','魅族']

# 设置随机数生成器的种子为 0
random.seed(0)

# 从品牌列表中随机选择一个品牌，并将其赋值给变量 name
name = brandlist[random.randint(0, 4)]

# 打印出被选中的品牌名称
print(name)

解析：

random.seed(0) 这句代码是为了设置随机数生成器的种子。在这段代码中，我们将种子设置为 0，这意味着每次运行程序时生成的随机数序列都是相同的。这样做的好处是，如果我们在程序中使用了随机数，那么每次运行程序时它们都会是相同的，这样就可以保证程序的可重复性。

random.randint(0, 4) 这句代码是用来生成一个在 0 到 4 之间的随机整数。其中 random 是 Python 内置的随机数模块，

randint 是该模块中的一个函数，用于生成指定范围内的随机整数。

---

8.

键盘输入一段文本，保存在一个字符串变量s中，分别用Python内置函数及jieba库中已有函数计算字符串s的中文字符个数及中文词语个数。注意:中文字符包含中文标点符号。
例如,
键盘输入:
科技是第一生产力
屏幕输出:
中文字符数为8，中文词语数为4。

import jieba
s = input("请输入一个字符串")
n = len(s)
m = len(jieba.lcut(s))
print("中文字符数为{}，中文词语数为{}。".format(n, m))

解析：

len(jieba.lcut(s)) 这句代码是用来计算一个字符串 s 中包含的中文词语数量。其中 jieba 是一个中文分词库，lcut 是该库中的一个函数，用于将一个中文字符串切分成一个一个的词语，并返回一个列表。

9.

使用turtle库的turtle.right()函数和turtle.fd()函数绘制一个五角星，边长为200像素，内角度数为36，效果如下图所下。

from turtle import *
for i in range(5):
   fd(200)
   right(144)

1. import turtle import*：从 turtle 库中导入了所有的函数和变量，包括 Turtle 类和一些常用的函数，如 fd() 和 right()。

2. for i in range(3): 使用for循环语句，循环5次，其中i的取值分别为0，1，2，3，4，5。

3.fd(200) 函数向前移动 200 个像素

4. right(144) 函数向右旋转 144 度

---

10.

键盘输入一组人员的姓名、性别、年龄等信息，信息间采用空格分隔，每人一行，空行回车结束录入，示例格式如：
张猛 男35
杨青 女18
汪海 男26
孙倩 女22
计算并输出这组人员的平均年龄(保留1位小数)和其中女性人数，结果保存在考生文件夹下，格式如下:
平均年龄是25.2女性人数是2

# 打开一个文件，以写入模式写入数据
fo = open("PY202.txt", "w")

# 从用户输入中读取一组人员的姓名、性别、年龄
data = input("请输入一组人员的姓名、性别、年龄：")  # 姓名 性别 年龄

# 初始化变量
women_num = 0    # 女性人数
age_amount = 0   # 年龄总和
person_num = 0   # 总人数

# 当有输入时，继续执行
while data:
    # 从输入中获取姓名、性别、年龄
    name, sex, age = data.split(" ")

    # 如果性别为女，则女性人数加1
    if sex == "女":
        women_num += 1

    # 年龄总和增加当前输入的年龄
    age_amount += int(age)

    # 总人数加1
    person_num += 1

    # 继续读取下一组人员的姓名、性别、年龄
    data = input("请输入一组人员的姓名、性别、年龄：")

# 计算平均年龄
average_age = age_amount / person_num

# 将结果写入文件
fo.write("平均年龄是{:.1f} 女性人数是{}".format(average_age, women_num))

# 关闭文件
fo.close()

---

11.

法定节假日是根据各国、各名族的风俗习惯或纪念要求，由国家法律统一规定的用以进行庆祝及度假的休息时间。法定节假日制度是国家政治、经济、文化制度的重要反映，涉及经济社会的多个方面，涉及广大人民群众的切身未法定节假日的休假安排，为居民出行购物和休闲提供了时间上的便利，为拉动内需、促进经济增长做出了积极益。贡献。给出一个2018年的节假日的放假日期CSV文件(PY301-vacations.csv)，内容示例如下:
1 元旦1230 101
2 春节215 0221
3 清明节0405 0407
4 劳动节0501 0503
5 端午节0616 0618
6 中秋节0922 0924
7 国庆节1001 1007
以第1行为例，1230表示12月30日，0101表示1月1日。

问题1(5分):在PY301-1.py文件中修改代码，读入CSV文件中数据，获得用户输入。根据用户输入的节假日名称，输出此节假日的假期范围。
参考输入和输出示例格式如下:
请输入节假日名称(例如，春节):春节
春节的假期位于0215-0221之间

问题2(10分):在PY301-2.py文件中修改代码，读入CSV文件中数据，获得用户输入。用户键盘输入一组范围是1-7的整数作为序号，序号间采用空格分隔，以回车结束。屏幕输出这些序号对应的节假日的名称、假期范围，每个节假日的信息一行。本次屏幕显示完成后，重新回到输入序号的状态。
参考输入和输出示例格式如下:
请输入节假日序号:15
元旦(1) 假期是12月30日至01月01日之间
端午节(5)假期是06月16日至06月18日之间
请输入节假日序号:

问题3(5分):在问题2的基础上，在PY301-3.py文件中修改代码，对键盘输入的每个序号做合法性处理。如果输的数字不合法，请输出”输入节假日编号有误!"，继续输出后续信息，然后重新回到输入序号的状态。
参考输入和输出示例格式如下:
请输入节假日序号:5 14 11
端午节假期是06月16日至06月18日之间
输入节假日编号有误!
输入节假日编号有误!
请输入节假日编号:

# PY301-1.py

fi = open("PY301-vacations.csv","r")
ls = []
for line in fi:
      ls.append(line.strip("\n").split(","))
fi.close()
s = input("请输入节假日名称")
for line in ls:
      if s == line[1]:
            print("{}的假期位于{}-{}之间".format(line[1],line[2],line[3]))

# PY301-2.py

fi = open("PY301-vacations.csv","r")
ls = []
for line in fi:
      ls.append(line.strip("\n").split(","))
fi.close()
s = input("请输入节假日序号").split(" ")
while True:
      for i in s:
            for line in ls:
                  if i == line[0]:
                        print("{}的假期位于{}-{}之间".format(line[1],line[2],line[3]))
      s = input("请输入节假日序号").split(" ")

# PY301-3.py

# 打开文件PY301-vacations.csv，以只读模式打开文件
fi = open("PY301-vacations.csv","r")

# 创建一个空列表ls
ls = []

# 读取文件中的每一行，去除行末的换行符，然后以逗号为分隔符将字符串分割成一个列表，将该列表添加到ls中
for line in fi:
      ls.append(line.strip("\n").split(","))

# 获取用户输入，将其以空格为分隔符分割成一个列表
s = input("请输入节假日序号").split(" ")

# 进入无限循环
while True:
      # 遍历用户输入的节假日编号列表
      for i in s:
            # 创建一个标志变量flag，用于判断用户输入的节假日编号是否正确
            flag = False
            # 遍历列表ls中的每一个元素
            for line in ls:
                  # 如果用户输入的节假日编号匹配上了列表中的某个元素的第一个值
                  if i == line[0]:
                         # 输出该节假日的名称、编号、开始月份、开始日期、结束月份和结束日期
                         print("{}({})假期是{}月{}日至{}月{}日之间".format(line[1]),line[0],line[2][:-2],line[2][-2:],line[3][:-2],line[3][-2:])
                        # 将标志变量flag设为True
                        flag = True
      # 如果标志变量flag为False，则说明用户输入的节假日编号有误，输出提示信息
      if flag == False:
            print("输入节假日编号有误！")
      # 获取用户输入，将其以空格为分隔符分割成一个列表
      s = input("请输入节假日序号").split(" ")

# 关闭文件
fi.close()

解析：

ls.append(line.strip("\n").split(","))：读取文件中的每一行，去除行末的换行符，然后以逗号为分隔符将字符串分割成一个列表，将该列表添加到ls中。

while True是一个无限循环语句，使程序一直重复执行后面包含的代码块，在这里的代码块的最后，程序会等待用户输入节假日编号，然后再次进入循环，直到程序被强制终止或满足某个终止条件。

flag = False的作用是创建一个标志变量flag，并将其初始化为False。在代码的后续执行过程中，如果某个条件满足，就将flag设为True。flag的作用是判断用户输入的节假日编号是否正确。当用户输入的节假日编号与列表中的某个元素的第一个值匹配时，将flag设为True。在每次循环结束后，如果flag的值为False，则说明用户输入的节假日编号有误。

---

12.

以255为随机数种子，随机生成5个在1(含)到50(含)之间的随机整数，每个随机数后跟随一个空格进行分隔，屏幕输出这5个随机数。

# 导入 random 模块
import random

# 设置随机数种子为 255
random.seed(255)

# 循环 5 次
for i in range(5):
    # 生成 1 到 50 之间的随机整数并打印，end=" " 表示以空格结尾而不是换行符
    print(random.randint(1, 50), end=" ")

这段代码使用了 random 模块来生成随机数。通过调用 random.seed(255) 方法，我们设置了随机数生成器的种子，这意味着每次运行程序时，生成的随机数序列都是相同的。然后，我们使用 for 循环来生成 5 个随机整数，并使用 print 函数将它们打印到屏幕上。

---

13.

使用turtle库的turtle.fd()函数和turtle.seth()函数绘制一个边长为200、画笔为2号笔的正五边形，正五边形5个内角均为108度。

# 导入 turtle 模块
import turtle

# 设置画笔宽度为 2
turtle.pensize(2)

# 设置角度增量为 72 度
d = 72

# 循环 5 次
for i in range(5):
    # 设置海龟的朝向为 d 度
    turtle.seth(d)

    # 将角度增量加上 72 度，为下一次循环做准备
    d += 72

    # 向当前朝向的方向前进 200 像素
    turtle.fd(200)

turtle.pensize(2): 方法设置画笔的宽度为 2 像素。

d=72:定义了一个变量 d，表示每次转向的角度增量，初始值为 72 度，即五角星的内角大小。

for i in range(5):循环来绘制五角星的每个顶点。

turtle.seth(d): 方法来设置海龟的朝向为当前角度 d,

turtle.fd(200): 方法向当前朝向的方向前进 200 像素，即绘制五角星的一条边。

d += 72:最后我们将角度增量加上 72 度，为下一次循环做准备，直到绘制完五角星的所有边。

---

14.

键盘输入某班各个同学就业的行业名称，行业名称之间用空格间隔(回车结束输入)。完善Python代码，统计各行业就业的学生数量按数量从高到低方式输出。

# 打开一个名为 PY202.txt 的文件，以写入模式打开
fo = open("PY202.txt","w")

# 从命令行输入同学们的行业名称，使用空格分隔
names = input("请输入各个同学行业名称，行业名称之间用空格间隔（回车结束输入）：")

# 将输入的字符串按照空格分隔成一个 list
name_lsit = names.split(" ")

# 创建一个空字典
d = {}

# 遍历输入的行业名称列表，统计每个行业出现的次数
for item in name_lsit:
    d[item] = d.get(item, 0) + 1

# 将字典转换为列表，按照行业出现的次数进行排序（从大到小）
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 按照数量排序

# 遍历排序后的列表，将行业名称和出现次数写入文件中
for k in ls:
    fo.write("{}:{}\n".format(k[0], k[1]))

# 关闭文件
fo.close()

解析：

d[item] = d.get(item, 0) + 1 ：d[item]表示字典d中item对应的值，d.get(item, 0)表示从字典d中获取item对应的值，如果没有找到，则返回0。+1表示将item对应的值加一。所以，这句代码的意思是，如果字典d中已经有item这个键，就将它的值加一；如果没有，就将它的值设为1。这样可以统计item在某个序列中出现的次数1。

list(d.items()) ：d 是一个字典，d.items() 是字典的一个方法，它返回一个包含字典所有项的列表，每个项都表示为一个 (key, value) 元组。作用是将字典 d 转换为一个列表 ls，其中每个元素都是一个 (key, value) 元组，表示字典中的一项。这样做的目的是为了方便对字典中的项进行排序和遍历。

---

15.

这里给出了一个网络版本的《论语》，文件名称为“论语.txt"，其内容采用逐句“原文”与逐句“注释”相结合的形式组织，通过【原文】标记《论语》原文内容，通过【注释】标记《论语》注释内容，具体文件格式框架请参考“论语.txt”文件。
问题1(10分):在PY301-1.py文件中修改代码，提取“论语txt”文件中的原文内容，输出保存到考生文件夹下,文件名为“论语-原文txt”。具体要求，仅保留“论语.txt”文件中所有【原文】标签下面的内容，不保留标签，并去掉每行行首空格及行尾空格，无空行。原文小括号及内部数字是源文件中注释项的标记，请保留。示例输出文件格式请参考“论语-原文-输出示例txt”文件。注意:示例输出文件仅帮助考生了解输出格式，不作它用。
问题2(10分):在PY301-2.py文件中修改代码，对“论语-原文txt“或“论语.txt“文件进一步提纯，去掉每行文字中所有小括号及内部数字，保存为“论语-提纯原文.txt"文件。示例输出文件格式请参考“论语-提纯原文-输出示例txt"文件。注意:示例输出文件仅帮助考生了解输出格式，不作它用。

# PY301-1.py
# 打开文件 "论语.txt"，以读取（"r"）模式打开，并返回一个文件对象
fi = open("论语.txt", "r")

# 打开文件 "论语-原文.txt"，以写入（"w"）模式打开，并返回一个文件对象
fo = open("论语-原文.txt", "w")

# flag 表示是否正在处理一条经文
flag = False

# 逐行读取文件 "论语.txt" 中的内容
for line in fi:
    # 如果当前行包含 "【"，说明这是一条新的经文的开始，flag 设为 False
    if "【" in line:
        flag = False
    # 如果当前行包含 "】"，说明这是经文的标题，flag 设为 True，并跳过当前循环
    if "】" in line:
        flag = True
        continue
    # 如果 flag 为 True，说明正在处理一条经文，将当前行去掉左侧空格后写入文件 "论语-原文.txt" 中
    if flag == True:
        fo.write(line.strip())

# 关闭文件 "论语.txt" 和 "论语-原文.txt"
fi.close()
fo.close()

解析：

flag的初始值是False，表示还没有遇到原文部分。

当遇到"【"时，说明开始了一个新的章节，此时将flag设为False，表示还没有遇到原文部分。

当遇到"】"时，说明结束了一个章节的标题，此时将flag设为True，表示接下来的行都是原文部分。

当flag为True时，就将当前行写入文件fo中，否则就跳过当前行。

这样就可以实现从文件fi中提取原文部分，并写入文件fo中。

# 打开一个名为"论语-原文.txt"的文件，以只读模式
fi = open("论语-原文.txt", "r")
# 打开一个名为"论语-提纯原文.txt"的文件，以写入模式
fo = open("论语-提纯原文.txt", "w")
# 遍历文件fi中的每一行
for line in fi:
    # 从1到22，遍历所有可能的注释编号
    for i in range(1, 23):
        # 将当前行中的"(i)"替换为空字符串，即去掉注释编号
        line = line.replace("({})".format(i),"")
    # 将处理后的行写入文件fo中
    fo.write(line)
# 关闭文件fi和fo
fi.close()
fo.close()

解析：

题目（2）要求对“论语-原文.txt”进一步提纯，保存为“论语-提纯原文.txt”文件，因此需要用"r"模式打开“论语-原文.txt”，用"w"模式创建文件“论语提纯原文.txt”。

题目要求去掉每行文字中所有小括号及内部数字，可在for循环遍历“论语原文.txt"文件中的每一行时，用空来代替出现的“(数字)"形式。分析“论语-原文.txt”文件可知，其中出现“(1)”~“(22)”一共22种可能，因此内部嵌套for循环需要从1遍历到22，构造“(i)”并替换。替换后将该行内容写入到文件“论语-提纯原文.txt”中。

---

16.

键盘输入一段中文文本，不含标点符号和空格，命名为变量txt，采用jieba库对其进行分词，输出该文本中词语的平均长度，保留1位小数。

import jieba
txt = input("请输入一段中文文本:")
ls = jieba.lcut(txt)
print("{:.1f}".format(len(txt)/len(ls)))

lcut 函数对一个中文文本进行分词，结果为一个包含了每个词汇的列表。每个词汇都是一个字符串。

{:.1f} 是 Python 中格式化字符串的一种方式，用于将一个浮点数格式化为一个小数点后保留一位的字符串。其中，{} 表示一个占位符，.1f 表示将这个占位符格式化为一个小数点后保留一位的浮点数。“:”是格式化字符串的语法结构的一部分，用于分隔格式说明符和格式化表达式。它的作用是告诉 Python 解释器，后面的字符串是一个格式说明符，用于格式化输出的值。

---

17.

键盘输入一个9800到9811之间的正整数n，作为Umicode编码，把n-1、n和n+1三个Unicode编码对应字符按照如下格式要求输出到屏幕:宽度为11个字符，加号字符+填充，居中。

n = eval(input("请输入一个数字:"))
print("{:+^11}".format(chr(n-1)+chr(n)+chr(n+1)))

chr 是一个 Python 内置函数，用于将一个 Unicode 编码转换为对应的字符。chr 函数的返回值是一个字符串，表示对应的字符。

---

18.

从键盘输入4个数字，各数字采用空格分隔，对应为变量x0,y0,x1,y1。计算两点(x0,y0)和(x1,y1)之间的距离，屏幕输出这个距离，保留1位小数。
例如:键盘输入:3 4 8 0屏幕输出: 6.4

ntxt = input("请输入4个数字(空格分隔):")
nls = ntxt.split(" ")
x0 = eval(nls[0])
y0 = eval(nls[1])
x1 = eval(nls[2])
y1 = eval(nls[3])
r = pow(pow(x1-x0, 2) + pow(y1-y0, 2), 0.5)
print("{:.1f}".format(r))

pow是Python的一个内置函数，它可以返回x的y次方（x y）的值。如果提供了第三个参数mod，它还可以对结果进行取模运算（x y % mod）。例如，pow(2, 3)返回8，pow(2, 3, 5)返回3。

---

19.

键盘输入学习的课程名称及考分等信息，信息间采用空格分隔，每个课程一行，空行回车结束录入，示例格式如下:
数学98
语文89
英语94
物理74
科学87
屏幕输出得分最高的课程及成绩，得分最低的课程及成绩，以及平均分(保留2位小数)，输出结果保存在考生文件夹，命名为“PY202.txt”。
注意，其中逗号为英文逗号，格式如下:
最高分课程是数学98,最低分课程是物理74平均分是88.40

# 打开一个名为PY202.txt的文件，以写入模式打开，如果文件不存在则创建
fo = open("PY202.txt","w")

# 获取用户输入的课程名及对应的成绩，将其存储在字典course_score_dict中
data = input("请输入课程名及对应的成绩：")  # 课程名 考分
course_score_dict = {}
while data:
    course, score = data.split(' ')
    course_score_dict[course] = eval(score)  # 将成绩转换为数字并存储在字典中
    data = input("请输入课程名及对应的成绩：")

# 对成绩进行排序，获取最高分、最低分和平均分
course_list = sorted(list(course_score_dict.values()))
max_score, min_score = course_list[-1], course_list[0]
average_score = sum(course_list) / len(course_list)

# 获取最高分和最低分对应的课程名
max_course, min_course = "", ""  # 初始化最高分和最低分对应的课程名为空字符串
for item in course_score_dict.items():
    if item[1] == max_score:
        max_course = item[0]
    if item[1] == min_score:
        min_course = item[0]

# 将结果写入文件并关闭文件
fo.write("最高分课程是{} {}, 最低分课程是{} {}, 平均分是{:.2f}".format(max_course, max_score, min_course, min_score, average_score))
fo.close()

解析：

data.split(' ') 是将字符串 data 按照空格进行分割，返回一个由分割后的子字符串组成的列表。例如，如果 data 的值为 "English 90"，那么 data.split(' ') 将返回 ["English", "90"]。

course,score = data.split(' ') 是将上述列表中的第一个元素 "English" 赋值给 course 变量，将第二个元素 "90" 赋值给 score 变量。这样就可以方便地获取用户输入的课程名和对应的成绩，存储在字典 course_score_dict 中。

course_score_dict.values() 返回字典 course_score_dict 中所有的值，即所有的成绩，返回结果是一个类似列表的对象。list(course_score_dict.values()) 将其转换为列表，然后用sorted()函数对列表进行排序，得到的结果赋值给变量 course_list。因此，course_list 是一个包含所有成绩的列表，按照从小到大的顺序排列。

max_course, min_course = "", "" 是将两个空字符串分别赋值给 max_course 和 min_course 变量，使得它们被初始化为空字符串。在程序开始时，这两个变量需要被初始化为空字符串，这样在后续的代码中才能正确处理最高分和最低分对应的课程名。

---

20.

下面所示为一套由公司职员随身佩戴的位置传感器采集的数据，文件名称为“sensor.txt”，其内容示例如下
2016/5/31 0:05,vawelon001,1,1
2016/5/31 0:20,earpa001,1,1
2016/5/31 2:26.earpa001,1.6
第一列是传感器获取数据的时间，第二列是传感器的编号，第三列是传感器所在的楼层，第四列是传感器所在的位置区域编号。
问题1(10分):在PY301-1.py文件中修改代码，读入sensor.txt文件中的数据，提取出传感器编号为earpa001的所有数据，将结果输出保存到“earpa001txt”文件。输出文件格式要求:原数据文件中的每行记录写入新文件中，行尾无空格，无空行。参考格式如下:
2016/5/31 7:11,earpa001,2,4
2016/5/31 8:02,earpa001,3,4
2016/5/31 9:22,earpa001,3,4
问题2(10分):在PY301-2.py文件中修改代码，读入“earpa001.txt”文件中的数据，统计earpa001对应的职员在各楼层和区域出现的次数，保存到“earpa001 counttxt文件，每条记录一行，位置信息和出现的次数之间用英文半角逗号隔开，行尾无空格，无空行。参考格式如下。
1-1,5
1-4,3

# 打开名为"earpa001.txt"的文件，以只读模式读取文件内容，将其赋值给变量fi
fi = open("earpa001.txt","r")

# 打开名为"earpa001_count.txt"的文件，以写入模式打开文件，将其赋值给变量fo
fo = open("earpa001_count.txt","w")

# 创建一个空字典，用于存储每个区域的数量统计结果
d = {}

# 遍历文件fi中的每一行
for line in fi:

  # 使用strip方法去除每行末尾的换行符，并使用split方法以逗号为分隔符将每行内容分割成一个列表
  split_data = line.strip("\n").split(",")

  # 将该行内容中倒数第二个元素和最后一个元素拼接成一个字符串，用于表示该行内容所属的区域
  floor_and_area = split_data[-2] + "-" + split_data[-1]

  # 如果该区域已经在字典d中，则将该区域对应的值加1
  if floor_and_area in d:
    d[floor_and_area] += 1
  # 如果该区域不在字典d中，则将该区域添加到字典d中，并将其对应的值设置为1
  else:
    d[floor_and_area] = 1

# 将字典d转换为列表，并按照列表中元素的第二个元素（即数量统计结果）从大到小排序
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 该语句用于排序

# 遍历排序后的列表，并将每个区域的数量统计结果写入文件fo中
for i in range(len(ls)):
  fo.write('{},{}\n'.format(ls[i][0],ls[i][1]))

# 关闭文件fi和fo
fi.close()
fo.close()

解析：

split_data[-2] + "-" + split_data[-1] :将该行内容中倒数第二个元素和最后一个元素拼接成一个字符串，用于表示该行内容所属的区域。

d[floor_and_area]是字典d中键为floor_and_area对应的值，d[floor_and_area] += 1即将字典d中键为floor_and_area的值加1。

ls = list(d.items())：将字典d转换为列表。

range(len(ls))：遍历次数设置为列表ls的长度。

---

21.

考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能: 以0为随机数种子，随机生成5个在1(含)到97(含)之间的随机数，计算这五个随机数的平方和。

import random
random.seed(0)
s = 0
for i in range(5):
    n = random.randint(1,97)  # 产生随机数
    s = s + n**2
print(s)

random.seed(0)：将随机数生成器的种子设置为 0。

---

22.

使用字典和列表型变量完成村长选举。某村有40名有选举权和被选举权的村民，名单由考生文件夹下文件name.txt给出，从这40名村民中选出一人当村长，40人的投票信息由考生文件夹下文件vote.txt给出，每行是一张选票的信息，有效票中得票最多的村民当选。
问题1:请从vote.txt中筛选出无效票写入文件votel.txt。有效票的含义是:选票中只有一个名字且该名字在name.txt文件列表中，不是有效票的票称为无效票。
问题2:给出当选村长的名字及其得票数。在考生文件夹下给出了程序框架文件PY202.py，补充代码完成程序。

# 打开名字文件
f = open("name.txt")
# 读取名字文件中的所有行
names = f.readlines()
# 关闭名字文件
f.close()

# 打开投票文件
f = open("vote.txt")
# 读取投票文件中的所有行
votes = f.readlines()
# 关闭投票文件
f.close()

# 打开输出文件
f = open("vote1.txt", "w")

# 初始化字典和计数器
D = {}
NUM = 0

# 遍历投票文件中的每一行
for vote in votes:
    # 统计每个投票中的候选人数
    num = len(vote.split())
    
    # 如果只有一个候选人且该候选人在名字文件中存在
    if num == 1 and vote in names:
        # 在字典中为该候选人加上一票
        D[vote[:-1]] = D.get(vote[:-1], 0) + 1
        # 增加有效票数计数器
        NUM += 1
    else:
        # 如果不符合条件，将该投票行写入输出文件
        f.write(vote)

# 关闭输出文件
f.close()

# 对字典按照值进行排序
l = list(D.items())
l.sort(key=lambda s: s[1], reverse=True)

# 获取得票最高的候选人的名字和得票数
name = l[0][0]
score = l[0][1]

# 输出结果
print("有效票数为：{} 当选村长村民为:{},票数为：{}".format(NUM, name, score))

解析：

len(vote.split())：是对字符串vote进行分割，返回分割后的子字符串列表，然后返回该列表的长度。这里的分割符是默认的空格符，也就是说，len(vote.split())返回的是字符串vote中单词的数量。在这段代码中，num的值表示当前选票中包含的单词数量，如果num等于1，说明该选票只包含了一个人的名字，这是有效选票，需要记录下来。如果num大于1，说明该选票不是有效选票，需要将其写入到vote1.txt文件中。

D.get(vote[:-1], 0)：表示从字典D中获取键为vote[:-1]的值，如果该键不存在，则返回默认值0。vote[:-1]是对字符串vote进行切片，表示从字符串开头到倒数第二个字符（不包括最后一个字符）的子字符串，这是因为读取文件时每行末尾都有一个换行符，需要将其去掉才能得到正确的名字。D[vote[:-1]]= D.get(vote[:-1], 0) + 1的作用是将字典D中键为vote[:-1]的值加1，如果该键不存在，则将其值设为1。这段代码的目的是统计每个人得到的有效选票数。

D.items()返回一个由字典D中的键值对组成的可迭代对象，其中每个元素都是一个二元组(key, value)，表示字典中的一个键值对。

list(D.items())将该可迭代对象转换为一个列表，其中每个元素都是一个二元组(key, value)，表示字典中的一个键值对。在这段代码中，l=list(D.items())的作用是将字典D中的键值对转换为一个列表l，以便对其进行排序。

sort()是对列表l进行排序，排序的依据是key参数指定的函数，如果key参数未指定，则默认使用元素的大小进行排序。

lambda s:s[1]是一个匿名函数，表示对于列表l中的每个元素s，取其第二个元素s[1]作为排序依据。在这段代码中，l是一个由字典D中的键值对组成的列表，因此s[1]表示每个键值对中的值，即每个人得到的有效选票数。

reverse=True表示倒序排序，即按照每个人得到的有效选票数从高到低排序。

l.sort(key=lambda s:s[1],reverse=True)的作用是对列表l按照每个人得到的有效选票数从高到低排序。排序后，l[0]表示得票最多的人的名字和得票数，即(name, score)。

---

23.

问题1:请编写程序，用Python语言中文分词第三方库jieba对文件data.txt进行分词，并将结果写入文件out.txt，每行一个词，例如:
内容简介
编辑
整个
故事
在
东汉
...
在考生文件夹下给出了程序框架文件 PY301-1.py，补充代码完成程序(10分)

import jieba
f = open('data.txt','r')   
lines = f.readlines()
f.close()
f = open('out.txt','w')    
for line in lines:     
    line = line.strip("")              #删除每行首尾可能出现的空格
    wordList = jieba.lcut(line)          #用结巴分词，对每行内容进行分词
    f.writelines('\n'.join(wordList))  #将分词结果存到文件out.txt中
f.close()

line = line.strip("") ：删除每行首尾可能出现的空格

wordList = jieba.lcut(line) ：用结巴分词，对每行内容进行分词

f.writelines('\n'.join(wordList)) ：将分词结果存到文件out.txt中

join 是一个字符串方法，它用于将一个可迭代对象中的元素连接起来，形成一个新的字符串。该方法的语法为 separator.join(iterable)，其中 separator 是分隔符，用于在连接后的字符串中分隔各个元素。在代码f.writelines('\n'.join(wordList))中，分隔符是换行符 '\n'，因此每个元素都会被写入一行。

问题2:对文件out.txt进行分析，打印输出曹操出现次数。在考生文件夹下给出了程序框架文件PY301-2.py，补充代码完成程序(10分)

import jieba
f = open('out.txt','r')    #以读的方式打开文件
words = f.readlines()
f.close()
D={}

for w in words:        #词频统计
    D[w[:-1]] = D.get(w[:-1 ], 0) + 1

print("曹操出现次数为:{}  ".format(D["曹操"]))

D.get(w[:-1], 0) ： 是用来获取字典 D 中键为 w[:-1] 的值。如果该键不存在，则返回默认值 0。因此，D[w[:-1]] = D.get(w[:-1], 0) + 1 这行代码的意思是：如果字典 D 中已经存在键为 w[:-1] 的项，则将其值加 1；否则，创建一个新的项，键为 w[:-1]，值为 0 + 1 = 1。

D["曹操"] ：表示获取字典 D 中键为 “曹操” 的值。

---

24.

在考生文件夹下存在一个Python源文件PY103.py，请编写代码替换横线，不修改其他代码，实现下面功能:让一个自然数n，如果n为奇数，输出表达式1+1/3+1/5+...+1/n的值，如果为偶数，输出表达式1/2+1/4+1/6+..用户输入+1/n的值。输出结果保留2位小数。示例如下(其中数据仅用于示意) :
输入：4 输出:0.75

def f(n):
    s = 0
    if n%2 == 1:
        for i in range(1, n+1, 2):
            s += 1/i
    else:
        for i in range(2, n+1, 2):
            s += 1/i
    return s
n = int(input())
print('{:.2f}'.format(f(n)))

for i in range(1, n+1, 2) ：是一个 Python 内置函数，它返回一个迭代器，表示从 1 开始，以 2 为步长，到 n+1 之前（不包括 n+1）的所有奇数。

{:.2f} ：保留2位小数

f(n) ：别忘调用函数

---

25.

在考生文件夹下有个文件PY201.py，在横线处填写代码，不修改其他代码，实现下面功能: 使用turtle库绘制三个彩色的圆，圆的颜色按顺序从颜色列表color中获取，圆的圆心位于(0.0) 坐标处，半径从里至外分别是10像素，30像素，60像素。

# 导入turtle模块并将其命名为t
import turtle as t

# 定义颜色列表
color = ['red','green','blue']

# 定义半径列表
rs = [10,30,60]

# 循环三次
for i in range(3):
    # 抬起画笔
    t.penup()
    # 移动到圆心位置
    t.goto(0, -rs[i])
    # 放下画笔
    t.pd()
    # 设置画笔颜色
    t.pencolor(color[i])
    # 画圆
    t.circle(rs[i])

# 结束turtle绘图
t.done()

import turtle as t：导入turtle模块并将其命名为t

t.penup()：抬起画笔

t.goto(0, -rs[i])：移动到圆心位置

t.pd()：放下画笔

t.pencolor(color[i])：设置画笔颜色

t.circle(rs[i])：画圆

t.done()；结束turtle绘图

---

26.

让用户输入一首诗的文本，内部包含中文逗号和句号。(1)用iieba库的精确模式对输入文本分词。将分词后的词语输出并以"/"分隔，统计中文词语数并输出，(2)以逗号和句号将输入文本分隔成单句并输出，每句一行，每行20个字符宽，居中对齐。在(1)和(2)的输出之间，增加一个空行。

# 导入jieba模块
import jieba

# 获取用户输入的中文文本
s = input("请输入一段中文文本，句子之间以逗号或句号分隔：")

# 对输入的文本进行分词
slist = jieba.lcut(s)

# 统计分词后的词语数
m = 0
for i in slist:
    # 如果分词结果是逗号或句号，则跳过
    if i in "，。":
        continue
    # 否则词语数加一，输出分词结果
    m += 1
    print(i, end="/")

# 输出中文词语数
print("\n中文词语数是：{}\n".format(m))

# 分行输出输入文本中的每个句子
ss = ""
for i in s:
    # 如果是逗号或句号，则先输出前面的字符串，再输出一个空行
    if i in "，。":
        print("{:^20}".format(ss))
        ss = ""
        continue
    # 否则将字符添加到字符串中
    ss += i

m = 0 ：设置计数器，在遍历的过程中，统计词语数

ss = "" ：初始化字符串。最后一个 for 循环的作用是将输入文本中的每个句子分行输出。具体来说，循环遍历输入文本中的每个字符，如果遇到逗号或句号，则将之前累积的字符串 ss 输出，并在下一行输出空行。如果不是逗号或句号，则将该字符添加到 ss 中，继续累积字符串。这样就可以将输入文本中的每个句子分行输出了。

---

27.

data.txt是由学生信息构成的数据文件，每行是一个学生的相关信息，包括姓名、班级和分数。姓名和其他信息之间用英文冒号隔开，班级和分数之间用英文逗号隔开，班级由“系名+班级序号”组成，如“计算191”。示例如下：
王一:计算191,340
张二:经济191,450
打开PY301-1.py，编程实现如下功能:
(1)读取data.txt，输出学生的姓名和分数到文件studs.txt，每行一条记录，姓名和分数用英文冒号隔开，示例如下.
王一:340
李四:450
打开PY301-2.py，编程实现如下功能:
(2)选出分数最高的学生，打印输出学生的姓名和分数，中间用英文冒号隔开，示例如下:
李四:450
打开PY301-3.py，编程实现如下功能:
(3)计算每个班级的平均分，打印输出班级和平均分，平均分小数点后保留2位，中间用英文冒号隔开，示例如下.
计算191:447.55
经济191:460.08

# PY301-1.py
fi = open('data.txt','r')
fo = open('studs.txt','w')

# 读取所有行并存储在变量 'students' 中
students = fi.readlines()

# 遍历 'students' 中的每一行
for i in students:
    # 移除行末的空白符并按 ':' 分割行
    i = i.strip().split(':')
    
    # 获取学生姓名
    name = i[0]
    
    # 获取学生最后一门课的分数
    score = i[1].split(',')[-1]
    
    # 将学生姓名和分数写入 'studs.txt' 文件中
    fo.write(name+':'+score+'\n')

fi.close()
fo.close()

# PY301-2.py
fi = open('data.txt','r')
students = fi.readlines()

l=[]
# 遍历 'students' 中的每一行
for i in students:
    # 移除行末的空白符并按 ':' 分割行
    i = i.strip().split(':')
    
    # 获取学生姓名
    name = i[0]
    
    # 获取学生最后一门课的分数
    score = i[1].split(',')[-1]
    
    # 将学生姓名和分数作为一个列表添加到 'l' 中
    l.append([name,score])

# 对 'l' 中的元素按照学生最后一门课的分数进行排序
l.sort(key=lambda x:eval(x[1]),reverse=True)

# 打印分数最高的学生姓名和分数
print(l[0][0]+':'+l[0][1])

fi.close()

# PY301-3.py

fi = open('data.txt','r')

d = {}
students = fi.readlines()

# 遍历 'students' 中的每一行
for i in students:
    # 移除行末的空白符并按 ':' 分割行
    i = i.strip().split(':')
    
    # 获取班级和最后一门课的分数
    clas,score = i[1].split(',')
    
    # 将分数添加到字典 'd' 中对应班级的值中
    d[clas] = d.get(clas,[])+[eval(score)]

# 遍历字典 'd' 中的每个键
for i in d:
    # 计算该班级所有学生的平均分数
    avg_score = sum(d[i])/len(d[i])
    
    # 打印该班级的名称和平均分数，保留两位小数
    print('{}:{:.2f}'.format(i,avg_score))

fi.close()

---

28.

在考生文件夹下存在一个Python源文件PY101.py，请编写代码替换横线，不修改其他代码，实现下面功能获得用户输入的一个整数，输出一个-1行的数字三角形阵列。该阵列每行包含的整数序列为从该行序号开始到n-1，例如第1行包含1到n-1的整数，第i行包含从到n-1的整数;数字之间用英文空格分隔。

n = eval(input("请输入一个整数："))

# 外层循环，控制输出的行数，从1到n-1
for i in range(1,n):
    # 内层循环，控制输出的列数，从1到n-1
    for j in range(1,n):
        # 如果列数大于等于行数，则输出列数，否则不输出
        if j >= i:
            print(j, end=' ')
    # 输出换行符，用于换行
    print()

在代码中，外层循环控制输出的行数，内层循环控制输出的列数。在内层循环中，如果列数大于等于行数，则输出列数，否则不输出。每行输出完毕后，使用 print() 函数输出一个换行符，用于换行。

---

29.

获得用户输入的5个小写英文字母，将小写字母变成大写字母，并逆序输出，字母之间用逗号分隔。

s = input("请输入5个小写字母：")
s = s.upper()
print(','.join(s[::-1]))

upper 方法将字符串中的小写字母转换为大写字母

join 方法将每个字母用逗号隔开并输出

---

30.

一个整数，记为n，以100为随机数种子，随机生成10个1到n之间的随机数，输出生成的随机数，数字获得用户输入的之间以逗号分隔。

import random
n = eval(input())
random.seed(100)
for i in range(1,11):
    if i<10:
        print(random.randint(1,n),end=",")
    else:
        print(random.randint(1,n))

[解题思路]题目要求输出10个随机数，观察代码需要填写两个位置，因为第2个空是在输出语句中，不能获取用户的输入，所以第1个空获取用户输入的数字，即第1个空为n = eval(input( "请输入一个整数: "))。然后在循环内需要生成多个随机数，因为数字之间需要用逗号隔开，最后一个数字后面无逗号，所以程序在输出最后一个数字的时候没有使用end参数，那么前面的输出语句就应该使用end设置输出数字的结尾，即第2个空应填入random.randint(1,n),end=","。

---

31.

使用turtle 库函数绘制4个等距排列的正方形，边长为40像素，间距宽度为40。最左边的正方形左上角坐标为(0.0)。

import turtle

# 定义正方形的数量
n = 4

# 循环画n个正方形
for j in range(n):
    turtle.pendown() # 落笔准备画图
    for i in range(4):
        turtle.fd(40) # 向前走40个像素
        turtle.right(90) # 右转90度
    turtle.penup() # 抬笔
    turtle.fd(80) # 向前走80个像素，准备画下一个正方形

turtle.done() # 完成绘图，等待退出

turtle.pendown() ：落笔准备画图

turtle.fd(40) ：向前走40个像素

turtle.right(90) ：右转90度

turtle.penup() ：抬笔

turtle.fd(80) ：向前走80个像素，准备画下一个正方形

---

32.

webpage.txt保存了某网站一个网页的HTML格式源代码。在该文件中，JPG图片以一个完整的URL表示，示例如下：

image.ngchina.com.cn/2019/538.JPG"/>
其中，与是一对组合，表示包含一个URL链接;表示包含一个JPG图像文件的URL，每个URL用src=开头，以JPG图像文件名结束，如538.JPG表示JPG图像文件。
打开PY301-1.py，编程实现如下功能:
(1)统计并打印输出该页面中JG图像文件的URI数量。注意，JPG扩展名都是大写字母，输出示例如下(其中数据仅用于示意):
输出:15
打开PY301-2.py，编程实现如下功能:
(2)将webpage.txt页面中的JPG图像文件的URL提取出来，保存在文件images.txt中，每个URL一行输出格式示例如下:(其中数据仅用于示意)
http://image.ngchina.com.cn/2018/0829/20180829012548753.JPG
http://image.ngchina.com.cn/2018/0823/thumb 469 352 20180823121155508JPG

# PY301-2.py

fi = open('webpage.txt')
fo = open("images.txt","w")
datas = fi.readlines()
d = ""

# 循环遍历所有行
for data in datas:
    # 如果当前行包含 .JPG
    if '.JPG' in data:
        # 将当前行以 src=" 为分隔符进行切割，取得包含图片链接的字符串，并将其存储在 data 变量中
        data = data.split('src="')[1].split('"')[0]
        # 将图片链接写入名为 images.txt 的文件中，并在末尾添加一个换行符
        fo.write(data + "\n")

data.split('src="')：将字符串 data 以 src=" 为分隔符进行切割，返回一个列表。

[1]：取切割后的列表的第二个元素，即包含图片链接的字符串。

split('"')[0]：将包含图片链接的字符串以 " 为分隔符进行切割，返回一个列表。然后取这个列表的第一个元素，即图片链接本身

fo.write(data + "\n")：将图片链接写入名为 images.txt 的文件中，并在末尾添加一个换行符

33.

在考生文件夹下存在一个Python源文件PY102.py，请编写代码替换横线，不修改其他代码，实现下面功能:就取一个由英文逗号、字母、汉字、数字字符组成的输入，计算该输入中所有数字的和，并输出。示例如下(其中数据仅用于示意):
输入:
1,海淀区,ab,56.3,中关村
输出:
数字和是:60

# 提示用户输入一串以逗号分隔的数字，并将其保存在变量 myinput 中
myinput = input("请输入：")

# 使用 split() 方法将字符串按逗号分隔成一个列表，并将其保存在变量 ls 中
ls = myinput.split(",")

# 初始化变量 s 为 0，用于累加数字的总和
s = 0

# 遍历列表 ls 中的每个元素 c
for c in ls:
    # 使用 strip() 方法去除元素 c 前后的空格，并检查是否为数字
    if c.strip(" ").isdigit():
        # 如果是数字，则将其转换为整数并加到变量 s 中
        s += eval(c)

# 输出数字总和，使用 str() 函数将整数 s 转换为字符串
print("数字和是：" + str(s))

isdigit() 方法被用于检查用户输入的每个字符串是否为数字。如果字符串是数字，则将其转换为整数并加到变量 s 中，否则将忽略该字符串，不进行累加操作。

eval() 是 Python 内置函数之一，用于将字符串作为表达式来求值。在这里，eval() 函数被用于将用户输入的字符串表示的数字转换为整数类型，并将其加到变量 s 中。由于用户输入的数字是以字符串形式存在的，因此需要使用 eval() 函数将其转换为整数类型，以便进行累加操作。

---

34.

(1)使用turtle库和random库，在屏幕上绘制5个彩色的圆;
(2)圆的颜色随机从颜色列表color中获取;
(3)圆的起始坐标x和值从范围[-100,100]之间选取，半径从范围[10.30]之间选取

import turtle as t
import ran

color = ['red','green','blue','purple','black']
r.seed(1)
for j in range(5):
    t.pencolor(color[r.randint(0, 4)])
    t.penup()
    t.goto(r.randint(-100, 100), r.randint(-100, 100))
    t.pendown()
    t.circle(r.randint(10, 30))
t.done()

t.pencolor(color[r.randint(0, 4)]) ： 随机选择一个颜色，并将其设置为画笔颜色

t.penup() ：抬起画笔，以便移动到新的绘制位置

t.goto(r.randint(-100, 100), r.randint(-100, 100)) ： 随机移动到一个新的绘制位置

t.pendown() ： 放下画笔，以便开始绘制圆圈

t.circle(r.randint(10, 30)) ： 绘制一个随机大小的圆圈

t.done() # 结束绘制，关闭 Turtle 窗口

---

35.

data3.txt文件内容示例如下:
商业模式价值链由三个环节组成:产品、工具、社区。我们团队以一站式系统开发为当前主要产品，利用XAMPP，PHPSTORM，微信开发者工具等软件根据客户要求提供合适的一体化管理系统。
打开PY301-1.py，编程实现如下功能
(1) 统计文件中出现词频最多的前10个长度不小于2个字符的词语，将词语及其出现的词频数按照词频数递减排序后显示在屏幕上，每行显示一个词语，用英文冒号连接词语及其词频。
打开PY301-2.py，编程实现如下功能
(2)将文档以中文逗号及中文句号为分隔符分割成短句，将包含最高词频的词语的句子，输出到文件out.txt中，每句一行

# PY301-2.py

import jieba

fi = open("data3.txt")
fo = open("out.txt","w")

# 读取"data3.txt"文件中的全部内容并存储在字符串变量"datas"中
datas = fi.read()

# 使用jieba分词对"datas"进行分词并存储在列表变量"data1"中
data1 = jieba.lcut(datas)

# 将"data1"中的"，"替换成"。"，并使用"。"进行分割，将分割后的结果存储在列表变量"data2"中
data2  = datas.replace("，"," 。").split("。")

# 创建一个空字典"d"
d = {}

# 遍历"data1"中的每个元素，并在字典"d"中记录各个词语的出现次数
for i in data1:
    if len(i) >= 2: # 如果词语长度大于等于2
        d[i] = d.get(i, 0) + 1 # 则在字典"d"中记录该词语的出现次数，如果该词语在字典中不存在，则默认出现次数为0

# 将字典"d"转换成列表"ls"，并按照各个词语的出现次数从大到小排序
ls = list(d.items())
ls.sort(key=lambda x:x[1],reverse=True)

# 遍历"data2"中的每个元素，如果列表"ls"中出现次数最多的词语在该元素中出现，则将该元素写入"out.txt"文件中
for j in data2:
    if ls[0][0] in j: # 如果列表"ls"中出现次数最多的词语在该元素中出现
        fo.write(j.strip() + "\n") # 则将该元素写入"out.txt"文件中，并在末尾添加换行符

fi.close()
fo.close()

---

36.

在考生文件夹下有个文件PY102.py，在横线处填写代码，完成如下功能。社会平均工作时间是每天8小时(不区分工作日和休息日)一位计算机科学家接受记者采访时说，他每天工作时间比社会平均工作时间多3小时。如果这位科学家的当下成就值是1，假设每工作1个小时成就值增加0.01%，计算并输出两个结果:这位科学家5年后的成就值，以及达到成就值100所需要的年数。其中，成就值和年数都以整数表示，每年以365天计算。

# 定义一个常量，表示每天的成就值增量
scale = 0.0001  

# 定义一个函数，用于计算给定基础成就值和天数后的成就值
def calv(base, day):
    # 计算出给定天数后的成就值，其中用到了数学函数 pow() 表示乘方
    val = base * pow(1+scale, day*11)
    return val

# 计算出5年后的成就值，并打印输出
print('5年后的成就值是{}'.format(int(calv(1, 5*365))))

# 初始化年数为1
year = 1

# 循环计算年数，直到成就值大于等于100
while calv(1, year*365) < 100:
    year += 1
    
# 输出需要的结果
print('{}年后成就值是100'.format(year))

定义常量 scale，表示每天的成就值增量；

定义函数 calv，用于计算给定基础成就值和天数后的成就值；

调用函数 calv 计算出 5 年后的成就值，并打印输出；

初始化年数为 1，然后循环计算年数，直到成就值大于等于 100，输出满足条件的年数。

pow是一个函数，用来计算一个数的另一个数的幂（次方）

---

37.

在考生文件夹下有个文件PY201.py，在横线处填写代码，完成如下功能。根据列表中保存的数据采用turtle库画图直方图，显示输出在屏幕上。1s =[69,292,33,131,61,254]

import turtle as t # 导入turtle模块，并用t作为别名
ls = [69, 292, 33, 131, 61, 254] # 定义一个列表，存储每个柱子的高度
X_len = 400 # 定义x轴的长度
Y_len = 300 # 定义y轴的长度
x0 = -200 # 定义x轴起点的横坐标
y0 = -100 # 定义x轴起点的纵坐标

t.penup() # 抬起画笔，不画线
t.goto(x0, y0) # 移动到x轴起点
t.pendown() # 放下画笔，开始画线

t.fd(X_len) # 向前画X_len个像素，画出x轴
t.fd(-X_len) # 向后画X_len个像素，回到原点
t.seth(90) # 设置画笔方向为90度（向上）
t.fd(Y_len) # 向前画Y_len个像素，画出y轴

t.pencolor('red') # 设置画笔颜色为红色
t.pensize(5) # 设置画笔粗细为5个像素
for i in range(len(ls)): # 对于列表中的每个元素（即每个柱子）
    t.penup() # 抬起画笔，不画线
    t.goto(x0 + (i+1)*50, -100) # 移动到柱子的左下角，横坐标间隔50个像素
    t.seth(90) # 设置画笔方向为90度（向上）
    t.pendown() # 放下画笔，开始画线
    t.fd(ls[i]) # 向前画ls[i]个像素，即柱子的高度
t.done() # 结束绘图

t.penup() # 抬起画笔，不画线

t.goto(x0, y0) # 移动到x轴起点

t.pendown() # 放下画笔，开始画线

t.fd(X_len) # 向前画X_len个像素，画出x轴

t.fd(-X_len) # 向后画X_len个像素，回到原点

t.seth(90) # 设置画笔方向为90度（向上）

t.fd(Y_len) # 向前画Y_len个像素，画出y轴

---

38.

考生文件夹下存在2个Python源文件和2个文本文件。其中，2个Python源文件对应2个问题，2个文本文件分别摘自2019年和2018年的政府工作报告。请分别补充2个Python源文件，实现以下功能。
问题1(10分):数据统计。要求:修改PY301-1.py文件中代码，分别统计两个文件中出现次数最多的10词语，作为主题词，要求词语不少于2个字符，打印输出在屏幕上，输出示例如下: (示例词语非答案)
2019改革:10,企业:9....(略),深化:2
2018:改革:11.效益:7..-.(略).深化:1
注意:输出格式采用英文冒号和英文逗号，标点符号前后无空格，各词语间用逗号分隔，最后一个词语后无逗号。
问题2(10分):数据关联。要求:修改PY301-2.py文件中代码，对比两组主题词的差异，输出两组的共有词语和分别的特有词语。输出示例如下:(示例词语非答案)
共有词语改革....(略).深化
2019特有:企业,..(略),加强
2018特有效益...(略)创新
注意:输出格式采用英文冒号和英文逗号，标点符号前后无空格，各词语间用逗号分隔，最后一个词语后无逗号。

import jieba  # 导入分词库

# 定义分词函数，接受一个文件名作为参数
def fenci(txt):
    f = open(txt, 'r')  # 打开文件
    datas = f.read()  # 读取文件内容
    f.close()  # 关闭文件
    data = jieba.lcut(datas)  # 使用结巴分词对文件内容进行分词
    d = {}  # 定义一个空字典，用于统计词频
    for i in data:  # 遍历分词结果
        if len(i) >= 2:  # 如果词语长度大于等于2
            d[i] = d.get(i, 0) + 1  # 将词语添加到字典中，并计数
    lt = list(d.items())  # 将字典转换为列表
    lt.sort(key=lambda x: x[1], reverse=True)  # 对列表进行降序排序
    ls = [x[0] for x in lt[:10]]  # 获取出现频率最高的前10个词语
    return ls

# 定义输出函数，接受一个列表作为参数
def show(lt):
    print(','.join(lt))  # 将列表元素用逗号连接起来，并输出

# 对两个文件进行分词并获取分词结果
l1 = fenci('data2018.txt')
l2 = fenci('data2019.txt')

l3 = []  # 定义一个空列表，用于存储两个文件中都出现的词语
for i in l1:
    if i in l2:  # 如果该词语也出现在第二个文件中
        l3.append(i)  # 将其添加到l3中
        l1.remove(i)  # 从l1中移除该词语
        l2.remove(i)  # 从l2中移除该词语

# 输出分析结果
print('共有词语:', end='', sep='')
show(l3)  # 输出两个文件中都出现的词语
print('2019特有:', end='', sep='')
show(l2)  # 输出仅在2019文件中出现的词语

sep是一个参数，它主要用于格式化输出屏幕上的打印语句123。它的默认值是空格，它可以在要打印的字符串之间添加一个分隔符。sep = value 是指定分隔符的值，可以是任何字符、整数或字符串。

ls = [x[0] for x in lt[:10]] ：是一个列表推导式，它的作用是从lt列表中取出前10个元素（也就是出现次数最多的10个词语和次数的元组），然后用x[0]表示每个元组的第一个元素（也就是词语本身），并将这些词语放入一个新的列表ls中。这样，ls就是一个包含了出现次数最多的10个词语的列表。

列表推导式（list comprehension），它是一种简洁的创建列表的语法。列表推导式的一般形式是：

[expression for item in iterable if condition]

expression是一个表达式，它可以对item进行任何操作；

item是一个变量，它可以从iterable中取出每一个元素；

iterable是一个可迭代对象，比如列表、元组、字符串等；

condition是一个可选的条件，它可以过滤出符合条件的元素。

列表推导式的作用是根据iterable中的每个元素，计算expression的值，并将结果放入一个新的列表中。如果有condition，那么只有满足条件的元素才会被计算和放入新列表中。

例如，假设我们有一个列表fruits = ['apple', 'banana', 'cherry', 'orange']，我们想要创建一个新的列表，只包含名字中有字母'a'的水果。不用列表推导式，我们需要写一个for循环和一个if判断：

new_list = []
for fruit in fruits:
    if 'a' in fruit:
        new_list.append(fruit)

用列表推导式，我们只需要一行代码：

new_list = [fruit for fruit in fruits if 'a' in fruit]

---

39.

在考生文件夹下有个文件PY201.py，在横线处填写代码，完成如下功能。利用random库和turtle库，在屏幕上绘制5个圆圈，圆圈的半径和圆初始坐标由randint0函数产生，圆的X和Y坐标范围在[-100,100]之间，半径的大小范围在[20.50]之间，圆圈的颜色随机在color列表里选择。效果如下图所示。

import turtle as t       # 导入 turtle 库并简写为 t
import random as r       # 导入 random 库并简写为 r
color = ['red','orange','blue','green','purple']  # 定义一个颜色列表
r.seed(1)               # 设置随机数生成器的种子为 1，保证每次运行结果相同
for i in range(5):      # 循环 5 次
    rad = r.randint(20, 50)         # 随机生成半径大小
    x0 = r.randint(-100,100)        # 随机生成圆心 x 坐标
    y0 = r.randint(-100,100)        # 随机生成圆心 y 坐标
    t.color(r.choice(color))        # 从颜色列表中随机选择一种颜色
    t.penup()                       # 抬起画笔
    t.goto(x0, y0)                  # 移动到圆心坐标处
    t.pendown()                     # 落下画笔
    t.circle(rad)                   # 画圆
t.done()                # 结束程序，并保持窗口不关闭

import turtle as t # 导入 turtle 库并简写为 t

import random as r # 导入 random 库并简写为 r

color = ['red','orange','blue','green','purple'] # 定义一个颜色列表

r.seed(1) # 设置随机数生成器的种子为 1，保证每次运行结果相同

rad = r.randint(20, 50) # 随机生成半径大小

x0 = r.randint(-100,100) # 随机生成圆心 x 坐标

y0 = r.randint(-100,100) # 随机生成圆心 y 坐标

t.color(r.choice(color)) # 从颜色列表中随机选择一种颜色

t.penup() # 抬起画笔

t.goto(x0, y0) # 移动到圆心坐标处

t.pendown() # 落下画笔

t.circle(rad) # 画圆

t.done() # 结束程序，并保持窗口不关闭

---

40.

在考生文件夹下有个文件PY202.py，定义了一个6个浮点数的一维列表lt1和一个包含3个数的一维列表1t2。
示例如下:
lt1 = [0.69,0.292,0.33,0.131,0.61,0.254]
lt2 = [0.1.0.8.0.2]
在横线处填写代码，完成如下功能。计算lt1列表跟lt2列表的向量内积两个向量X=[x1,x2,x3]和Y= [y1,y2,y3]的内积计算公式如下:
k =x1* y1 + x2* y2 +x3 * y3
将每次计算的两组对应元素的值、以及对应元素乘积的累计和(k)的值显示在屏幕上格式如下所示
k=0.069 1t2[0]=0.100 1t1[0+0]=0.690
k=0.303 ,1t2[1]=0.800 ,1t1[0+1]=0.292
k=0.369 ,1t2[2]=0.200 ,1t1[0+2]=0.330

# 定义输入图像(img)和卷积核(filter)
img = [0.244, 0.832, 0.903, 0.145, 0.26, 0.452]
filter = [0.1, 0.8, 0.1]

# 定义一个空列表，用于存储卷积的结果
res = []

# 迭代img列表中除最后两个元素外的所有元素
for i in range(len(img)-2):
    # 定义一个变量k，并将其初始化为0
    k = 0
    # 迭代卷积核(filter)中的每个元素以及对应窗口中的每个元素，并计算加权和
    for j in range(len(filter)):
        k += filter[j] * img[j+i]
        # 输出计算过程中的中间结果，方便理解
        print("k={:.3f} ,filter[{}]={:.3f} ,img[{}+{}]={:.3f}".format(k, j, filter[j], i, j, img[i+j]))
    # 将计算得到的加权和添加到结果列表中
    res.append(k)

# 输出卷积的结果
for r in res:
    print('{:<10.3f}'.format(r), end='')

解析 ：

首先，定义了一个输入图像(img)和一个卷积核(filter)。输入图像是一个包含6个元素的列表，卷积核是一个包含3个元素的列表。这两个列表的元素都是浮点数，用于进行卷积操作。

然后，定义了一个空列表res，用于存储卷积的结果。接着，使用两个for循环迭代输入图像(img)中除最后两个元素外的所有元素。在循环中，定义一个变量k，并将其初始化为0。然后，再次使用一个for循环，迭代卷积核(filter)中的每个元素以及对应窗口中的每个元素，并计算加权和。具体地，将卷积核(filter)中的每个元素与输入图像(img)中的对应元素相乘，然后将所有乘积相加，得到加权和。在计算过程中，输出计算结果以及相应的中间结果，方便理解。

将得到的加权和添加到结果列表res中。最后，使用一个for循环输出卷积的结果。

---

41.

考生文件夹下，存在2个Python源文件和1个文本文件。其中，2个Python源文件对应2个问题，文本文件“data.txt”中包含一篇从互联网上下载的关于“德国工业4.0战略规划实施建议摘要”的文章。请分别补充2个Python源文件，完成以下功能。
问题1(10分):文件内容清洗。要求:在文件PY301-1.py中补充代码，对文件datatxt的内容进行清理，去除中文标点符号，只保留中文、英文、数字、英文标点符号等字符，将结果输出到文件clean.txt中。示例如下:
德国工业4.0战略计划实施建议摘编机械工业信息研究院战略与规化研究所一德国实施工业...(略
问题2(10分):提取主题词及其出现频次。要求:在文件PY301-2.py中补充代码，提取cleantxt文件中长度不少于3个字符的词语并统计词频，将词频最高的10个词语作为主题词，并将主题词及其频次输出到屏幕。示例如下:
4.0:10,制造业:9....(略)
注意:输出格式采用英文冒号和英文逗号，标点符号前后无空格，各词语中间用逗号分隔，最后一个词语后无逗号。

import jieba

f = open('clean.txt', 'r')
data = f.read()

l = jieba.lcut(data)

# 初始化一个字典，用于存储词频统计结果
d = {}

# 遍历分词结果，统计每个词的出现次数
for i in l:
    if len(i) >= 3:  # 只统计长度大于等于3的词
        d[i] = d.get(i, 0) + 1

# 将统计结果转换为列表，按照出现次数从高到低排序
lt = list(d.items())
lt.sort(key=lambda x: x[1], reverse=True)

# 输出出现次数最高的前10个词及其出现次数
for i in lt[:9]:
    print(i[0], ':', i[1], end=',', sep='')
print(lt[9][0], ':', lt[9][1], sep='')

f.close()

两个print要分开写的原因是为了在输出的最后一个词语和次数后不加逗号，而是换行。如果将它们合并为一个print，那么就需要在lt列表中切片时去掉最后一个元素，然后在打印函数中添加最后一个元素，这样会增加代码的复杂度和长度。例如：

print(*[i[0]+':'+str(i[1])+',' for i in lt[:-1]], lt[-1][0]+':'+str(lt[-1][1]), sep='')

sep=“”表示不在输出之间添加空格。这一行没有指定end参数，所以默认为换行符’\n’。

---

42.

某班学生评选一等奖学金，学生的10门主干课成绩存在考生文件夹下文件score.txt中每行为一个学生的信息，分别记录了学生学号、姓名以及10门课成绩，格式如下:
1820161043 王一稿 68 66 83 77 56 73 61 69 66 78
1820161044 沈红伟 91 70 81 91 96 80 78 91 89 94
从这些学生中选出奖学金候选人，条件是:D总成绩排名在前10名，全部课程及格(成绩大于等于60)
问题1:给出按总成绩从高到低排序的前10名学生名单，并写入文件candidate0.txt，每行记录一个学生的信息，分别为学生学号、姓名以及10门课成绩。补充考生文件夹下文件PY301-1.py,完成这一功能。
问题2:读取文件candidate0.txt，从中选出候选人，并将学号和姓名写入文件candidatetxt.格式如下:
1010112161722 张三
1010112161728 李四
补充考生文件夹下文件PY301-2.py,完成这一功能

# PY301-1.py

fo = open("score.txt")
lines = fo.readlines()

fi = open("candidate0.txt","w")

L=[]  # L 中的元素是学生原始成绩和总成绩

# 遍历每一行，将其转换为一个学生列表，其中最后一个元素是原始成绩
# 计算学生的总成绩，并将其添加到学生列表的末尾
for line in lines:
    line = line.strip()
    student = line.split(" ")
    sum = 0
    for i in range(1, 11):
        sum += int(student[-1])
    student.append(str(sum))
    L.append(student)

# 按学生总成绩从大到小排序
L.sort(key=lambda x:x[-1],reverse=True)

# 将前十个学生的信息写入文件 candidate0.txt
for i in range(10):
    fi.write(" ".join(L[i][:-1]) + "\n")

fo.close()
fi.close()

# PY301-2.py

fo = open("candidate0.txt","r")
lines = fo.readlines()

# 创建一个新文件 candidate.txt，以便写入结果
fi = open("candiate.txt","w")

L = []  # 储存候选人

# 遍历每一行，将其转换为一个学生列表，其中最后十个元素是原始成绩
# 如果学生的任一科目成绩低于 60 分，则不将其添加到候选人列表中
# 否则，将学生的姓名和学号添加到候选人列表中
for line in lines:
    line = line.strip()
    student = line.split(" ")
    for i in student[:-10]:
        if int(i) < 60:
            break
        else:
            L.append(student[:2])

# 将所有候选人的姓名和学号写入文件 candidate.txt
for i in L:
    fi.write(" ".join(i) + "\n")

# 关闭文件
fo.close()
fi.close()

43.

获得用户输入的一个数字，对该数字以30字符宽度，十六进制，居中输出，字母小写，多余字符采用双引号(“)填充.

s = input()
print("{:\"^30x}".format(eval(s)))

x ：表示将数字转换为十六进制

d：将整数转换为十进制。

o：将整数转换为八进制。

b：将整数转换为二进制。

e：将浮点数转换为科学计数法表示法。

f：将浮点数转换为十进制表示法。

s：将字符串原样输出。

---

44.

获得用户输入的以逗号分隔的三个数字，记为a、b、c，以a为起始数值，b为前后相邻数的比值，c为数列长度产生一个等比数列，将这个数列以逗号分隔的形式输出，最后一个元素输出后无逗号。

a, b, c = [eval(x) for x in input().split(",")]
ls = []
for i in range(c):
    ls.append(str(a*(b**i)))
print(",".join(ls))

解析：

a, b, c = [eval(x) for x in input().split(",")] ：获取输入的以逗号分隔的三个数字

列表推导式（list comprehension），它是一种简洁的创建列表的语法。列表推导式的一般形式是：

[expression for item in iterable if condition]

expression是一个表达式，它可以对item进行任何操作；

item是一个变量，它可以从iterable中取出每一个元素；

iterable是一个可迭代对象，比如列表、元组、字符串等；

condition是一个可选的条件，它可以过滤出符合条件的元素。

列表推导式的作用是根据iterable中的每个元素，计算expression的值，并将结果放入一个新的列表中。如果有condition，那么只有满足条件的元素才会被计算和放入新列表中。

a*(b**i）：等比数列

---