Python二级程序题

题目来自

Python 二级在线
https://python2ji.com/

元素交替插入

请修改编辑器中的代码，完成以下功能：a 和 b 是两个列表变量，列表 a 为 [3,6,9]（已给定），用户从键盘输入列表 b。将 a 列表的三个元素分别插入到 b 列表中对应的前三个元素之后，并将结果在屏幕上输出。

输入示例： b 列表为 [1,2,3]

输出示例： 计算结果为 [1,3,2,6,3,9]

# 请在______处使用一行代码或表达替换
# 注意：请不要修改其他已给出代码

a = [3,6,9]
b = eval(input()) #例如：[1,2,3]
j=1
for i in range(len(a)):
    b.insert(i * 2 + 1, a[i])
print(b)

十六进制居中格式输出

请修改编辑器中的代码，完成以下功能：获取用户输入的一个数字，将该数字以30字符宽度、十六进制、居中格式输出，字母小写，多余字符使用符号@填充。

输入示例： 1234

输出示例： @@@@@@@@@@@@@4d2@@@@@@@@@@@@@@

#请完善如下代码,不得修改其他代码
#PY101.py

s = input()
print("{:@^30}".format(hex(int(s))[2:]))

你的考试成绩是

请修改编辑器中的代码，完成以下功能：将程序中定义好的 std 列表里的姓名和成绩与已经定义好的模板拼成一段话，显示在屏幕上。

输入示例： std 列表内容： [(“张三”, {“英语”: 90, “数学”: 87, “Python语言”: 95})]

输出示例： 亲爱的张三，你的考试成绩是:英语90,数学87,Python语言95,总成绩272.特此通知。

# 在____________上补充代码
#


std = [['张三',90,87,95],['李四',83,80,87],['王五',73,57,55]]
modl = "亲爱的{},你的考试成绩是:英语{},数学{},Python语言{},总成绩{}.特此通知."

for st in std:
    cnt = 0
    for i in range(1,4):
        cnt += st[i]
    print(modl.format(st[0],st[1],st[2],st[3],cnt))

两点之间直线最短哦

请修改编辑器中的代码，完成以下功能：从键盘输入4个数字，各数字用空格分隔，依次对应为变量 x0、y0、x1、y1，计算两点 (x0,y0) 和 (x1,y1) 之间的距离，结果保留2位小数并输出。

输入示例： 0 1 3 5

输出示例： 5.00

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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("{:.2f}".format(r))

叒是字符串格式化

请修改编辑器中的代码，完成以下功能：键盘输入正整数 n，将 n 输出到屏幕，格式要求：宽度为15个字符，数字右对齐，不足部分用 * 填充。

输入示例： 1234

输出示例： ***********1234

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

n = eval(input("请输入正整数:"))
print("{:*>15}".format(n))

叕是字符串格式化

请修改编辑器中的代码，完成以下功能：程序接收用户输入的五个数，以逗号分隔。将这些数字按照输入顺序输出，每个数字占10个字符宽度，右对齐，所有数字显示在同一行。

输入示例： 23,42,543,56,71

输出示例： 23 42 543 56 71

# 在____________上补充代码
# 


num = input().split(',')
for i in num:
    print('{:>10}'.format(int(i)), end=' ')

规范字母

请修改编辑器中的代码，完成以下功能：获取用户输入的5个小写英文字母，将小写字母变成大写字母，并逆序输出，字母之间用逗号分隔。

输入示例： qwert

输出示例： T,R,E,W,Q

# 编写代码替换横线
#

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

取模与精度

请修改编辑器中的代码，让用户输入一个自然数 n，如果 n 为奇数，输出表达式 1+1/3+1/5+…+1/n 的值；如果 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)))

随便的随机数

请修改编辑器中的代码，使用0作为随机数种子，随机生成5个在1（含）到97（含）之间的随机数，并计算这五个随机数的平方和。

示例： 若生成的五个随机数为 [10, 20, 30, 40, 50]，则平方和为 10^2 + 20^2 + 30^2 + 40^2 + 50^2 = 5500。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码
import random
random.seed(0)
s = 0
for i in range(5):
    n = random.randint(1,97)  # 产生随机数
    print(n)
    s = s + n**2  
print(s)

正中间的python

请修改编辑器中的代码，获取用户输入的一个符号作为填充字符，并将字符串PYTHON以30字符宽度居中对齐，剩余部分使用填充字符填充。

输出示例： ############PYTHON############

# 编写代码替换横线
#

a = input("请输入填充符号：")
s = "PYTHON"
print("{:{fill}^{width}}".format(s, fill=a, width=30))

随机与规范

请修改编辑器中的代码，完成以下功能：以 123 为随机数种子，随机生成10个在1（含）到999（含）之间的随机数，数字之间用逗号分隔，屏幕输出这10个随机数。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

import random
random.seed(123)
for i in range(10):
    print(random.randint(1,999), end=",")

整数随机抽取

请修改编辑器中的代码，完成以下功能：获取用户输入的三个整数，以逗号分隔，分别记为 n、m、k，其中 m > k。以 1 为随机数种子，产生 n 个在 k 和 m 之间的随机整数（包括 k 和 m），将这些随机数逐行输出，每个数占一行。

输入示例： 4,26,10

输出示例： 14 12 18 13

# 请在......处完善代码，可以修改其他代码

import random as r
r.seed(1)
s=input("请输入三个整数 n,m,k：")
slist=s.split(",")

n = int(slist[0])
m = int(slist[1])
k = int(slist[2])


for i in range(n):
    print(r.randint(k, m)) 

斐波那契数列

请修改编辑器中的代码，完成以下功能：根据斐波那契数列的定义，F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)(n>=2)，计算并输出不大于100的序列元素，结果以逗号分隔。

输出示例： 0,1,1,2,3,5,8,…（略）

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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

向量点积计算

请修改编辑器中的代码，完成以下功能：a 和 b 是两个列表变量，列表 a 为 [3,6,9]（已给定），键盘输入列表 b，计算 a 中元素与 b 中对应元素的乘积累加和。

输入示例： 键盘输入列表 b 为 [1,2,3]

输出示例： 42

计算过程说明： 13 + 26 + 3*9 = 42

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

a = [3,6,9]
b =  eval(input()) #例如：[1,2,3]
s = 0
for i in range(len(a)):
    s += a[i]*b[i]
print(s)

数字转中文

请修改编辑器中的代码，完成以下功能：获取用户输入的一个数字，将数字字符（0到9）用对应的中文字符“〇一二三四五六七八九”替换，并输出替换后的结果。

输入示例： 9081726354

输出示例： 九〇八一七二六三五四

#请完善如下代码,不得修改其他代码
#在________处填写一行或多行代码
#PY102.py

n = input()
s = "〇一二三四五六七八九"
for c in "0123456789":
     n = n.replace(c, s[int(c)], 1)
print(n)

按照格式输出小数

请修改编辑器中的代码，接收用户输入的一个浮点数，输出这个浮点数的小数部分各字符的和。结果要求以10为宽度，靠右对齐，并使用星号 * 进行填充。

输入示例： 1234.5678

输出示例： ********26

# 在____________上补充代码
#


s = input("请输入一个小数: ")
s = s[::-1]
cs = 0
for c in s:
    if c == '.':
        break
    cs += eval(c)
print('{:*>10}'.format(cs))

摘下时钟

请修改编辑器中的代码，完成以下功能：time 库是 Python 中用于时间处理的标准库，其中 time.ctime() 函数可以将一个表示时间的浮点数转换成人类可以理解的时间格式。请获得用户输入的一个时间数值，并提取并输出其中的小时信息。

输入示例： 1519181231.0

输出示例： 10

# 在____________上补充代码
#


import time
t = input("请输入一个浮点数时间信息: ")
s = time.ctime(float(t))
ls = s.split()
print(ls[3].split(':')[0]) 

反转输出

请修改编辑器中的代码，完成以下功能：获取用户输入的一个字符串，将字符串逆序输出，并紧接着输出字符串的字符个数。

输入示例： Python编程

输出示例： 程编nohtyP7

#请完善如下代码
s = input()
print(s[::-1],end='')
print(len(s))

生成等比数列

请修改编辑器中的代码，完成以下功能：获取用户输入的以逗号分隔的三个数字，分别记为 a、b、c，其中 a 为起始数值，b 为前后相邻数的比值，c 为数列长度。生成一个等比数列，并以逗号分隔的形式输出，最后一个元素后无逗号。

输入示例： 2,3,4

输出示例： 2,6,18,54

#请完善如下代码,不得修改其他代码
#PY103.py

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

三个星座

请修改编辑器中的代码，完成以下功能：键盘输入一个9800到9811之间的正整数 n，将 n-1、n 和 n+1 这三个Unicode编码对应的字符按照指定格式输出到屏幕，格式要求为：宽度为11个字符，用加号字符 + 填充并居中对齐。

输入示例： 9802

输出示例： ++++♈♉♊++++

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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

随机立方和

请修改编辑器中的代码，完成以下功能：以 100 为随机数种子，随机生成3个在1（含）到9（含）之间的随机数，计算这三个随机数的立方和。

示例过程： 假设生成的三个随机数为 [2, 4, 6]，则立方和为 2^3 + 4^3 + 6^3 = 288。

# 请在______处使用一行或多行代码替换
#
# 注意：请不要修改其他已给出代码

import random
random.seed(100)  # 此处可多行
s = 0  # 
numbers = [random.randint(1,9) for _ in range(3)]
s = sum([x**3 for x in numbers])# 此处可多行
print(s)

上三角数列生成

请修改编辑器中的代码，完成以下功能：获取用户输入的一个整数 n，输出一个包含 n-1 行的数字三角形阵列。该阵列的每一行是从该行的序号开始到 n-1 的整数序列，数字之间用英文空格分隔。

输入示例： 8

输出示例： 1 2 3 4 5 6 7 2 3 4 5 6 7 3 4 5 6 7 4 5 6 7 5 6 7 6 7 7

# 编写代码替换横线
#

n = eval(input("请输入一个整数："))
for i in range(1,n):
    for j in range(1,n):
        if j>= i:
            print(j,end=' ')
    print()

往左偏头是笑脸

请修改编辑器中的代码，接收键盘输入一个正整数 n，并按要求将其输出到屏幕。格式要求：宽度为20个字符，使用减号字符 - 进行填充，数字右对齐，带千位分隔符。如果输入的正整数超过20位，则按照真实长度输出。

输入示例： 1234

输出示例： ---------------1,234

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

n = eval(input("请输入正整数:"))
print("{:->20,}".format(n))

等差数列

请修改编辑器中的代码，获取用户输入的以逗号分隔的三个数字，分别记为 a、b、c，以 a 为起始数值，b 为差，c 为数值的数量，生成一个递增的等差数列，并将这个数列以列表格式输出。

输入示例： 2,3,4,

输出示例： [2, 5, 8, 11]。

#请完善如下代码
a, b, c = map(int,input().split(','))
ls = []
for i in range(c):
    ls.append(a + i * b)
print(ls)

数字居中二号

请修改编辑器中的代码，完成以下功能：键盘输入正整数 n，按要求将 n 输出到屏幕，格式要求：宽度为14个字符，数字居中对齐，不足部分用 = 填充。

输入示例： 56789

输出示例： =56789==

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

n = eval(input("请输入正整数:"))
print("{:=^14}".format(n))

随机元素种子

请修改编辑器中的代码，用户输入一个数字作为种子，以26个小写字母和0~9数字为基础，随机生成10个8位密码，并将每个密码在单独一行打印输出。

# 在____________上补充代码

import random

s = input("请输入随机种子: ")
ls = []
for i in range(26):
    ls.append(chr(ord('a')+i))
for i in range(10):
    ls.append(chr(ord('0') + i))
    
random.seed(int(s))
for i in range(10):
    for j in range(8):
        print(random.choice(ls),end='')
    print()

好多右箭头啊

请修改编辑器中的代码，接收用户输入的一个小于20的正整数，在屏幕上逐行递增显示从01到该正整数。数字显示的宽度为2，不足位置补0，后面追加一个空格，然后显示>符号，>符号的个数等于行首数字。

输入示例： 3

输出示例： 01> 02>> 03>>>

# 在____________上补充代码
#


n = input('请输入一个正整数:')
for i in range(1,int(n)+1):
    print('{:02}{}'.format(i, '>' * i))
          

时间与成就值

请修改编辑器中的代码，计算以下内容：社会平均工作时间为每天8小时（不区分工作日和休息日），一位计算机科学家接受记者采访时说他每天工作时间比社会平均工作时间多3小时。假设这位科学家的当下成就值为1，并且每工作1小时成就值增加0.01%。编写程序计算并输出两个结果：这位科学家5年后的成就值，以及达到成就值100所需要的年数。每年按365天计算。

输出格式： 5年后的成就值是XXX XX年后成就值是100

# 在____________上补充代码
#


scale = 0.0001  # 成就值增量

def calv(base, day):
    val = base * pow(1 + 11 * scale,day)
    return val

print('5年后的成就值是{}'.format(int(calv(1, 5*365))))
      
year = 1
while calv(1, year * 365) < 100:
    year += 1
    
print('{}年后成就值是100'.format(year))

元素对应相加

请修改编辑器中的代码，完成以下功能：a 和 b 是两个长度相同的列表变量，列表 a 为 [3,6,9]（已给定），键盘输入列表 b，计算 a 中元素与 b 中对应元素的和，形成新的列表 c，并在屏幕上输出。

输入示例： 键盘输入列表 b 为 [1,2,3]

输出示例： 计算结果为 [4,8,12]

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

a = [3,6,9]
b =  eval(input()) #例如：[1,2,3]
c = []
for i in range(len(a)):
    c.append(a[i] + b[i])
print(c)

给我来个随机列表

请修改编辑器中的代码，完成以下功能：获取用户输入的一个整数，记为 n，以 100 为随机数种子，随机生成10个1到 n 之间的随机数，并输出生成的随机数，数字之间以逗号分隔。

输入示例： 900

输出示例： 150,471,466,790,777,723,403,750,359,444

# 编写代码替换横线
#

import random
n = int(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))

又是字符串格式化

请修改编辑器中的代码，完成以下功能：键盘输入正整数 n，按要求将 n 输出到屏幕。格式要求：宽度为25个字符，等号 = 填充，右对齐，带千位分隔符。如果输入正整数超过25位，则按照实际长度输出。

输入示例： 1234

输出示例： ====================1,234

#请完善如下代码
s = input()
print("{:=>25}".format(f"{int(s):,}"))

数字个数与字母个数

请修改编辑器中的代码，完成以下功能：让用户输入一串由数字和字母混合组成的数据，统计其中数字和字母的个数，并在屏幕上显示。

输入示例： Fda243fdw3

输出示例： 数字个数：4，字母个数：6

# 在____________上补充代码
#


ns = input("请输入一串数据：")
dnum,dchr = 0,0
for i in ns:
    if i.isnumeric():
        dnum += 1
    elif i.isalpha():
        dchr += 1
    else:
        pass
print('数字个数：{}，字母个数：{}'.format(dnum,dchr))

字符数与词组统计

请修改编辑器中的代码，完成以下功能：键盘输入一段文本，保存在字符串变量 s 中，分别使用 Python 内置函数及 jieba 库中的函数计算字符串 s 的中文字符个数及中文词语个数。注意：中文字符包括中文标点符号。

输入示例： 俄罗斯举办世界杯

输出示例： 中文字符数为8，中文词语数为3。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

import jieba
s = input("请输入一个字符串")
n = n = len(s)
m = len([word for word in jieba.lcut(s) if word.strip() != ''])
print("中文字符数为{}，中文词语数为{}。".format(n, m))

字母序列生成

请修改编辑器中的代码，完成以下功能：按照小写字母 a 到 z 顺序组成包含26个字母的字符表，其中，第一个字符 a 序号为 0，依次递增。程序获取用户输入的起始字母序号及连续输出字母的个数，分别记为变量 h 和 w，以逗号隔开，并根据字符表输出从起始字母序号 h 开始的连续 w 个字母。

输入示例： 0,3

输出示例： abc

# 在____________上补充代码 （12根短线）
#不要修改其他代码
#

h,w = eval(input("请输入起始英文字母的序号和连续输出的个数，逗号隔开:"))
cstr = ''
for i in range(h, h + w):
    c = chr(97 + i)
    cstr += c
print(cstr)

# 在____________上补充代码 （12根短线）
#不要修改其他代码
#

h,w = eval(input("请输入起始英文字母的序号和连续输出的个数，逗号隔开:"))
cstr = ''
for i in range(h, h + w):
    c = chr(ord('a') + i)
    cstr += c
print(cstr)

漫无止境的简单格式化

请修改编辑器中的代码，完成以下功能：键盘输入字符串 s，将 s 按宽度20个字符居中对齐，使用等号 = 进行填充。如果输入字符串超过20位，则全部输出。

输入示例： PYTHON

输出示例： =PYTHON=

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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

怎么没有一加

请修改编辑器中的代码，完成以下功能：随机选择一个手机品牌并在屏幕上输出。品牌列表包含：[‘华为’, ‘苹果’, ‘诺基亚’, ‘OPPO’, ‘小米’]。

# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：请不要修改其他已给出代码

import random
brandlist = ['华为','苹果','诺基亚','OPPO','小米']
random.seed(0)
name = random.choice(brandlist)
print(name)

数字字符求和

请修改编辑器中的代码，完成如下功能：接收用户输入的一个大于10且小于108的十进制正整数，并输出该正整数各位数字的和，结果需要以25为宽度居中显示，并使用等号 = 进行填充。

输入示例： 1357

输出示例： ==16=

# 在____________上补充代码


s = input("请输入一个正整数: ")
cs = 0
for c in s:
    cs += int(c)
print('{:=^25}'.format(cs))

数字和

请修改编辑器中的代码，完成以下功能：获取一个由英文逗号、字母、汉字、数字字符组成的输入，计算该输入中所有数字字符的和，并输出。

输入示例： 32,英特尔,ab,32,3,苹果

输出示例： 数字和是：67

# 编写代码替换横线
#

myinput = input("请输入：")
ls = myinput.split(',')
s = 0
for c in ls:
    if c.strip(" ").isdigit():
        s += int(c.strip(""))
print("数字和是：" + str(s))

让我们说中文

请修改编辑器中的代码，完成以下功能：用户按照列表格式输入数据，将用户输入的列表中属于字符串类型的元素连接成一个完整的字符串，并打印输出。

输入示例： [3,“让”,“我们”, 98, “说中文”]

输出示例： 让我们说中文

# 在____________上补充代码
ls = eval(input())
s = ""
for item in ls:
    if type(item) == type("香山"):
        s += item
print(s)

倒着说话的结巴

请修改编辑器中的代码，完成以下功能：键盘输入一句话，使用 jieba 进行分词，然后将切分后的词组按照原话中的逆序输出到屏幕上，词组之间没有空格。

输入示例： 学习Python很有趣

输出示例： 有趣很Python学习

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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

猜猜数字

请修改编辑器中的代码，完成以下功能：以 25 为种子，随机生成一个1～100之间的整数，让用户来猜，用户最多可以猜6次。接收用户输入的数字，按以下规则判断：

如果输入的数字和随机数相同，则输出“恭喜你，猜对了!”，程序结束。 如果输入的数字小于随机数，则输出“小了，请再试试”，程序继续。 如果输入的数字大于随机数，则输出“大了，请再试试”，程序继续。 若6次还没猜对，在判断大小后输出“谢谢!请休息后再猜”，然后程序退出。

# 在____________上补充代码
#

import random

random.seed(25)
n = random.randint(1,100)
for m in range(1,7):
    x = eval(input("请输入猜测数字："))
    if x == n:
        print("恭喜你，猜对了！")
        break
    elif  x > n:
        print("大了，再试试")
    else:
        print("小了，再试试")
    if m == 6:
        print("谢谢！请休息后再猜")

最大值计算

请修改编辑器中的代码，完成以下功能：接收用户输入的一组以英文逗号分隔的整数或浮点数，打印输出这组数据中的最大值。

输入示例： 1.2,3.4,5.6,7.8,9.0

输出示例： 9.0

# 在____________上补充代码
#


s = input("请输入一组数据: ")
ls = s.split(',')
lt = []
for i in ls:
    lt.append(float(i))
print(max(lt))

词除以字

请修改编辑器中的代码，完成以下功能：键盘输入一段中文文本（不含标点符号和空格），命名为变量 s，使用 jieba 库对其进行分词，并输出该文本中词语的平均长度，保留1位小数。

输入示例： 你最喜欢的一句歌词是

输出示例： 1.4

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

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

浮点格式化

请修改编辑器中的代码，完成以下功能：获取用户输入的浮点数，以10字符宽度、右对齐的方式输出该浮点数，小数点后保留2位。

输入示例： 5.98320

输出示例： 浮点数是: 5.98

# 在____________上补充代码 （12根短线）
#不要修改其他代码
#


f = eval(input("请输入一个浮点数:"))
print("浮点数是:{:10.2f}".format(f))

中文字符计数

请修改编辑器中的代码，完成以下功能：接收用户输入的一段仅由字母和中文构成的字符串，统计并输出其中中文字符的个数。

输入示例： world世界peace和平

输出示例： 4

# 在____________上补充代码
#


s = input("请输入中文和字母的组合: ")
count = 0
for c in s:
    if not ('a' <= c <= 'z' or 'A' <= c <= 'Z'):
        count += 1
print(count)

打折与总额

请修改编辑器中的代码，完成以下功能：某商店出售某品牌运动鞋，每双定价160元，1双不打折，2双（含）到4双（含）打九折，5双（含）到9双（含）打八折，10双（含）以上打七折。键盘输入购买数量，屏幕输出总额（保留整数）。

输入示例： 1

输出示例： 总额为: 160

# 请在...处使用一行或多行代码替换
#
# 注意：请不要修改其他已给出代码

n = eval(input("请输入数量："))
price_per_pair = 160
if n == 1:
    cost = price_per_pair
elif 2 <= n <= 4:
    cost = price_per_pair * n * 0.9
elif 5 <= n <= 9:
    cost = price_per_pair * n * 0.8
else:
    cost = price_per_pair * n * 0.7

print("总额为:",cost)

向量积

请修改编辑器中的代码，完成以下功能：计算两个列表 ls 和 lt 对应元素乘积的累加和（即向量积）。

数据示例： ls = [111, 222, 333, 444, 555, 666, 777, 888, 999] lt = [999, 777, 555, 333, 111, 888, 666, 444, 222]

计算说明： 向量积 = 111999 + 222777 + 333555 + … + 999222

#请补充若干行代码，完成向量积运算
ls = [111, 222, 333, 444, 555, 666, 777, 888, 999]
lt = [999, 777, 555, 333, 111, 888, 666, 444, 222]
s = 0
for i in range(len(ls)):
    s += ls[i] * lt[i]
print(s)
 

小星星

请修改编辑器中的代码，完成以下功能：利用 random 库和 turtle 库，在屏幕上绘制4个小雪花。雪花的中心点坐标由列表 points 给出，雪花的半径长度由 randint() 函数产生，雪花的颜色为红色。

坐标示例： points = [(0, 0), (50, 50), (-50, -50), (100, -100)]

# 在____________上补充代码
# 请不要修改其他代码
#

import turtle as t
import random as r

r.seed(1)
t.pensize(2)
t.color('red')
angles = 6
points= [[0,0],[50,40],[70,80],[-40,30]]

for i in range(4):
    x0,y0 = points[i]
    t.penup()
    t.goto(x0,y0)
    t.pendown()

    length = r.randint(6, 16)
    for j in range(angles):
        t.forward(length)
        t.backward(length)
        t.right(360 / angles)
t.done()

统计中文词语数

请修改编辑器中的代码，完成以下功能：让用户输入一首诗的文本，文本中包含中文逗号和句号。要求如下：

使用 jieba 库的精确模式对输入文本进行分词，分词后的词语用 / 分隔输出，统计并输出中文词语数。 使用逗号和句号将输入文本分隔成单句，每句独立输出，每行宽度为20字符，居中对齐。 在(1)和(2)的输出之间增加一个空行。

输入示例： 就让我们忘了所有的哪些说过的话吧，在那个秋夜所有的一切都是无心之举

输出示例： 就让/我们/忘/了/所有/的/哪些/说/过/的话/吧/在/那个/秋夜/所有/的/一切都是/无心/之/举/

中文词语数是：20

就让我们忘了所有的哪些说过的话吧 在那个秋夜所有的一切都是无心之举

# 在……上补充一行或多行代码
#
import jieba
s = input("请输入一段中文文本，句子之间以逗号或句号分隔：")
slist = jieba.cut(s)
m = 0
word_list = []

for i in slist:
   if i in "，。":
      continue
   else:
       m += 1
       word_list.append(i)
print('/'.join(word_list)+'/')
      
print("\n中文词语数是：{}\n".format(m))

senses = s.replace('，','。').split('。')
for i in senses:
    print('{:^20}'.format(i,''))

简单正方形

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个边长为200像素的正菱形，菱形的四个内角均为90度，效果如图所示。

# 请在______处使用一行代码替换
#
# 注意：请不要修改其他已给出代码

import turtle
turtle.pensize(2)
d = -45
for i in range(4):
    turtle.seth(d)
    d  += 90
    turtle.fd(200)

正八边形绘制

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个边长为100像素的正八边形。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

import turtle
turtle.pensize(2)
d = 0
for i in range(1,9):
    turtle.fd(100)
    d += 45
    turtle.seth(d)

村长选举

请修改编辑器中的代码，完成以下功能，使用字典和列表型变量模拟村长选举：

某村有40名具有选举权和被选举权的村民，名单保存在 name.txt 文件中。从这40名村民中选出一人当村长，投票信息保存在 vote.txt 文件中，每行是一张选票的信息。有效票中得票最多的村民当选。程序需要实现下面两个功能：

一：请从 vote.txt 中筛选出无效票并写入文件 vote1.txt。有效票的含义是：选票中只有一个名字且该名字在 name.txt 文件列表中，不符合此条件的票即为无效票。

二：统计有效票中得票最多的村民，输出当选村长的名字及其得票数。

# 以下代码仅供参考
f=open("name.txt","r",encoding='utf-8')
names=f.readlines()
f.close()
f=open("vote.txt","r",encoding='utf-8')
votes=f.readlines()
f.close()
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))

是数字就继续加

请修改编辑器中的代码，完成以下功能： 不断获取用户输入，要求输入内容不包含数字。 如果用户的输入中存在数字，则提示重新输入，直到输入的内容全部为非数字字符。 输入符合条件后，输出用户输入字符的总个数。

输入示例： abc123 输出示例： 请重新输入

输入示例： hello world 输出示例： 输入字符数为：11

#请完善如下代码
#在....处填写多行代码，不得修改其他代码
#PY202.py


while True:
    s = input("请输入不带数字的文本:")
    i = 0 
    for p in s:
        if "0"<=p<="9":
            i=i+1
    if i==0:
        break
print(len(s))

国家大学分布统计

请修改编辑器中的代码，完成以下功能：读取文件 data.txt 中的内容并统计上榜大学的分布情况。文件内容格式如下，每行包含大学排名、名称、所属国家，各字段用英文逗号隔开。 统计并输出上榜国家的数量。并对每个国家，输出该国家上榜大学的数量和名称。

文件内容示例： 1,麻省理工学院,美国 2,斯坦福大学,美国 3,哈佛大学,美国 4,牛津大学,英国 5,剑桥大学,英国

输出示例： 美国：3:麻省理工学院 斯坦福大学 哈佛大学 英国：2:牛津大学 剑桥大学

# 以下代码仅供参考
# 在____________上补充一行代码
# 可以修改代码
#




import csv
f = open('data.txt','r')
unis=[]
L=list(csv.reader(f))
L=list(filter(None,L))
country = {}
for j in range(len(L)):
    country[L[j][2]] = country.get(L[j][2],0)+1

for key in country:
    ss=[]
    ss.append(key)
    ss.append(country[key])
    school=""
    for j in range(len(L)):
        if L[j][2] == key:
            school += L[j][1]
            school += " "
    ss.append(school)
    unis.append(ss)

for d in unis:
    print('{:>4}: {:>4} : {}'.format(d[0],d[1],d[2]))

四个正方形

请修改编辑器中的代码，完成以下功能：使用 turtle 库函数绘制4个等距排列的正方形。正方形的边长为40像素，间距宽度为40，最左边正方形的左上角坐标为 (0,0)。

import turtle
n = 4
for j in range(n):
    turtle.pendown()
    for i in range(4):
        turtle.fd(40)
        turtle.right(90)
    turtle.penup()
    turtle.fd(80)
turtle.done()

考分统计

请修改编辑器中的代码，完成以下功能：键盘输入小明学习的课程名称及考分信息，信息间采用空格分隔，每个课程一行，空行回车结束录入。程序将输出得分最高的课程及成绩，得分最低的课程及成绩，以及平均分（保留2位小数）。

输入示例： 物理 88 数学 92 历史 85 生物 78 化学 90

输出示例： 最高分课程是数学 92, 最低分课程是生物 78, 平均分是86.60

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准


data = input()  # 课程名 考分
d={}
while data:
    t=data.split()
    d[t[0]]=t[1]
    data = input()
ls=list(d.items())
ls.sort(key=lambda x:x[1],reverse=True)
s1,g1=ls[0]
s2,g2=ls[len(ls)-1]
a=0
for i in d.values():
    a=a+int(i)
a=a/len(ls)
print("最高分课程是{} {}, 最低分课程是{} {}, 平均分是{:.2f}".format(s1,g1,s2,g2,a))

随机的圆

请修改编辑器中的代码，完成以下功能：利用 random 库和 turtle 库，在屏幕上绘制5个圆圈。圆圈的半径和圆心的坐标由 randint() 函数产生，圆心的 X 和 Y 坐标范围在 [-100,100] 之间，半径大小范围在 [20,50] 之间。圆圈的颜色从 color 列表中随机选择。

# 在____________上补充代码

import turtle as t
import random as r
color = ['red','orange','blue','green','purple']
r.seed(1)
for i in range(5):
    rad = r.randint(20,50)
    x0 = r.randint(-100,100)
    y0 = r.randint(-100,100)
    t.color(r.choice(color))
    t.penup()
    t.goto(x0,y0)
    t.pendown()
    t.circle(rad)
t.done()

有这个名字吗

请修改编辑器中的代码，完成以下功能： 定义一个包含若干名字字符串的列表 persons。 在该列表中查找用户输入的名字字符串： 如果找到该名字，则生成一个四位数字组成的随机验证码，并输出该名字和验证码。 如果未找到，则输出提示“对不起，您输入的名字不存在。” 若用户输入字母 q，则退出程序。 显示提示信息后再次显示“请输入一个名字：”提示用户输入，重复执行步骤2。程序在用户输入3次后自动退出。

示例： 假设 persons = [‘Alice’, ‘John’, ‘Sarah’, ‘David’]

输入示例： Alice 输出示例： Alice 2456

输入示例： Emma 输出示例： 对不起，您输入的名字不存在。

输入示例： q 输出示例： 程序自动退出

# 在……上补充一行或多行代码，不得修改其他代码
#

import random as r
r.seed(0)
persons = ['Aele', 'Bob','lala', 'baicai']
flag = 3
while flag>0:
    flag -= 1
    name = input("请输入一个名字：")
    num = r.randint(1000,9999)
    if name in persons:
        print('{} {}'.format(name, num))
    elif name == "q":
        break
    else:
        print('对不起，您输入的名字不存在。')
    

姓名-年龄-性别

请修改编辑器中的代码，完成以下功能：键盘输入一组人员的姓名、性别、年龄等信息，信息间采用空格分隔，每人一行，空行回车结束录入。程序计算并输出这组人员的平均年龄（保留2位小数）和其中男性人数。

输入示例： 张三 男 35 李四 男 21 王五 男 18

输出示例： 平均年龄是24.67 男性人数是3

# 以下代码为提示框架
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

data = input()  # 姓名 年龄 性别
s=0
n=0
i=0
while data:
    i=i+1
    ls=data.split()
    s=s+int(ls[2])
    if ls[1]=='男':
        n=n+1
    data = input()
s=s/i
print("平均年龄是{:.2f} 男性人数是{}".format(s,n))

大方块和小方块

请修改编辑器中的代码，完成以下功能：使用 turtle 库和 random 库，绘制四个彩色的正方形。正方形的颜色从颜色列表 color 中随机选择，边长在 [50,200] 之间随机选取。每个正方形的左下角坐标 (x, y) 从 [-100,100] 范围中随机选择。

# 在____________上补充代码 （12根短线）
#

import turtle as t
import random as r
color = ['red','blue','purple','black']
r.seed(1)
for j in range(4):
    t.pencolor(color[r.randint(0,3)])
    t.penup()
    t.goto(r.randint(-100,100), r.randint(-100,100))
    t.pendown()
    ra = r.randint(50, 200)
    for i in range(1,5):
        t.fd(ra)
        t.seth(90*i)
t.done()

反正不是a股

请修改编辑器中的代码，完成以下功能：根据列表 Ls 中的数据，使用 turtle 库绘制柱状图，并将图形显示在屏幕上。 数据列表示例： Ls = [69, 292, 33, 131, 61, 254]

# 在____________上补充代码
# 请不要修改其他代码
#

import turtle as t
ls = [69, 292, 33, 131, 61, 254]
X_len = 400
Y_len = 300
x0 = -200
y0 = -100

t.penup()
t.goto(x0, y0)
t.pendown()

t.fd(X_len)
t.fd(-X_len)
t.seth(90)
t.fd(Y_len)

t.pencolor('red')
t.pensize(5)
for i in range(len(ls)):
    t.penup()
    t.goto(x0 + (i+1)*50, y0)
    t.seth(90)
    t.pendown()
    t.fd(ls[i])
t.done()

等边三角形

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个等边三角形，边长为200像素。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

import turtle as t
for i in range(3):
    t.seth(i*120)
    t.fd(200)

红绿蓝圆

请修改编辑器中的代码，完成以下功能：使用 turtle 库绘制三个彩色的圆，圆的颜色按顺序从 color 列表中获取。圆的圆心位于 (0,0) 坐标处，半径从里至外分别是10像素、30像素、60像素。

# 在____________上补充代码

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.pendown()
    t.pencolor(color[i])
    t.circle(rs[i])
t.done()

开盒辣

请修改编辑器中的代码，完成以下功能：在已定义好的字典 pdict 中，有一些人名及其电话号码。请用户输入一个姓名，在字典中查找该用户的信息：

如果找到，则生成一个四位数字的验证码，并输出该姓名、电话号码和验证码。 如果找不到该用户信息，则显示“对不起，您输入的用户信息不存在。” 字典示例： pdict = {‘Alice’: ‘1234567890’, ‘Bob’: ‘234567891’, ‘Charlie’: ‘9876543210’}

输入示例： Bob 输出示例： Bob 234567891 1926

输入示例： Tom 输出示例： 对不起，您输入的用户信息不存在。

# 在......上补充一行或多行代码
# 不得修改其他代码
#

import random
random.seed(2)

pdict= {'Alice':['123456789'],
        'Bob':['234567891'],
        'Lily':['345678912'],
        'Jane':['456789123']}

name = input('请输入一个人名:')
if name in pdict:
    print("{} {} {}".format(name,pdict.get(name)[0],random.randint(1000,9999)))
else:
    print("对不起，您输入的用户信息不存在。")

移动平均滤波器

请修改编辑器中的代码，完成以下功能：给定两个一维列表 lt1 和 lt2，计算 lt1 列表与 lt2 列表的向量内积。向量内积计算公式为： K = x1y1 + x2y2 + x3*y3，其中每次计算包含两组对应元素的值及累计和。

输入示例： lt1 = [0.69, 0.292, 0.33, 0.131, 0.61, 0.254] lt2 = [0.1, 0.8, 0.2]

输出格式示例： k=0.069, filter[0]=0.100, img[0+0]=0.690 k=0.303, filter[1]=0.800, img[0+1]=0.292 k=0.369, filter[2]=0.200, img[0+2]=0.330

#请在.....处填写多行表达式或语句
#不得修改其他代码

img = [0.244, 0.832, 0.903, 0.145, 0.26, 0.452]
filter = [0.1,0.8,0.1]
res = []
for i in range(len(img)-2):
    k = 0
    for j in range(3):
        k+=filter[j]*img[i+j]
        print('k={:<10.3f},filter[{}]={:<10.3f},img[{}+{}]={:<10.3f}'.format(k,j,filter[j],i,j,img[i+j]))
    res.append(k)
for r in res:
    print('{:<10.3f}'.format(r),end = '')

五边形

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个边长为100的正五边形。

#请在______处使用一行或多行代码替换
#
# 注意：请不要修改其他已给出代码

import turtle
turtle.pensize(2)
d = 0
for i in range(1,6):
    turtle.fd(100)
    d += 72
    turtle.seth(d)

执行时间排行

请修改编辑器中的代码，完成以下功能：在文件 out.txt 中，有一些数据库操作的执行时间信息，文件格式如下：

starting,0.000037,2.102 After opening tables,0.000008,0.455 System lock,0.000004,0.227 Table lock,0.000008,0.455 …

其中第1列是操作名称，第2列是操作所花费的时间，第3列是该操作所占全部过程的百分比。字段之间用英文逗号 隔开 程序要求：

读取 out.txt 文件中的内容，统计所有操作的时间总和并输出。 输出操作时间占比最高的三个操作的百分比值及其对应的操作名称。

输出示例： the total execute time is 0.0017 the top 0 percentage time is 46.023, spent in “Filling schema table”

# 以下代码仅供参考
#请在.....处填写多行表达式或语句
#请在_____处填写一行表达式或代码
#不得修改其他代码

sumtime = 0
percls = []
ts = {}
with open('out.txt', 'r') as f:
    for line in f:
        percls.append(line.strip('\n').split(","))

n=[x[1] for x in percls]
for i in range(len(n)):
    sumtime+=eval(n[i])

ts={x[0]:x[2] for x in percls}

print('the total execute time is ', sumtime)

tns = list(ts.items())
tns.sort(key=lambda x: x[1], reverse=True)
for i in range(3):
    print('the top {} percentage time is {}, spent in "{}" operation'.format(i, tns[i][1],tns[i][0]))

五彩缤纷的泡泡们

请修改编辑器中的代码，完成以下功能：使用 turtle 库和 random 库，在屏幕上绘制5个彩色的圆。

圆的颜色从颜色列表 color 中随机选择。 圆的圆心坐标 (x, y) 在 [-100, 100] 范围内随机选择。 圆的半径在 [10, 30] 范围内随机选择。

import turtle as t
import random as r

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()

随机方块之旅

请修改编辑器中的代码，完成以下功能：利用 random 库和 turtle 库，在屏幕上绘制3个黑色的正方形。正方形的左下角坐标和边长由 randint() 函数产生，具体参数在代码中给出。

# 在____________上补充代码
# 请不要修改其他代码
#


import turtle as t
import random as r
r.seed(1)
t.pensize(2)
for i in range(3):
    length = r.randint(20,80)
    x0 = r.randint(-100, 100)
    y0 = r.randint(-100, 100)

    t.penup()
    t.goto(x0,y0)
    t.pendown()
    for j in range(4):
        t.forward(length)
        t.setheading(90*(j+1))
t.done()

现在选的专业就是当年脑袋里进的水

请修改编辑器中的代码，完成以下功能：

键盘输入一组高校所对应的学校类型，以空格分隔，共一行。 程序统计各类型的数量，并按数量从多到少的顺序输出每种类型及对应数量，每个类型占一行，格式为“类型: 数量”，其中冒号为英文字符。 输入示例： 综合 理工 综合 综合 综合 师范 理工

输出示例： 综合: 4 理工: 2 师范: 1

# 以下代码为提示框架
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

txt = input("请输入类型序列: ")
t=txt.split()
d = {}
for i in range(len(t)):
    d[t[i]]=d.get(t[i],0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True)  # 按照数量排序
for k in ls:
    print("{}:{}".format(k[0], k[1]))

不要标点

请修改编辑器中的代码，定义一个字符串 dela=‘-;:,.()"<>’，包含了需要去除的字符。获取用户输入的文本，去除字符串 dela 中的字符，使用 jieba 进行精准分词，并统计词语的个数。最后输出结果，格式如下：

输入示例： <<-就让我们忘了所有的哪些说过的话吧>>

输出示例： 里面有11个词语。

# 在____________上补充代码 （12根短线）
#请在.....处填写多行表达式或语句
#可以修改其他代码

#
# 在……上补充一行或多行代码 （6个点）
#
import jieba
dela = '-;:,.()"<>'
s = input("请输入一句话:")
print("\n这句话是:{}".format(s))
for i in dela:
    s=s.replace(i, "")
ls = jieba.lcut(s)
print("替换之后是:{}".format(s))
print("里面有 {}个词语。".format(len(ls)))

十二边形

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个边长为40像素的正12边形。

#301，请在空格处补充代码
import turtle
turtle.pensize(2)
d=0
for i in range(1,13):
    turtle.fd(40)
    d += 30
    turtle.seth(d)

左手画个外接圆

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.left() 函数绘制一个边长为200像素的正方形，并在正方形的四个顶点处绘制一个紧挨正方形的圆形。

'''
在横线处补充代码，不得修改其它代码
'''
#PY201.py
import turtle
turtle.pensize(2)
for i in range(4):
    turtle.fd(200)
    turtle.left(90)
turtle.left(-45)
turtle.circle(100*pow(2,0.5))

十字

请修改编辑器中的代码，完成以下功能：使用 turtle 库的 turtle.fd() 函数和 turtle.seth() 函数绘制一个十字形，每个方向的长度为100像素。

# 请在______处使用一行代码或表达式替换
#
# 注意：请不要修改其他已给出代码

import turtle
for i in range(4):
    turtle.fd(100)
    turtle.fd(-100)
    turtle.seth((i+1)*90)

各行各业

请修改编辑器中的代码，完成以下功能：键盘输入某班各个同学就业的行业名称，行业名称之间用空格间隔（回车结束输入）。统计各行业的就业人数，并按数量从高到低排序输出。

输入示例： 交通 金融 计算机 交通 计算机 计算机

输出示例： 计算机:3 交通:2 金融:1

# 以下代码为提示框架
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

names=input("请输入各个同学行业名称，行业名称之间用空格间隔（回车结束输入）：")
t=names.split()
d = {}
for c in range(len(t)):
    d[t[c]]=d.get(t[c],0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 按照数量排序
for k in range(len(ls)):
    zy,num=ls[k]
    print("{}:{}".format(zy,num))

2018-1

请修改编辑器中的代码，完成以下功能： 分别统计两个文本文件中出现次数最多的10个词语（要求词语不少于2个字符），并作为主题词输出。 输出格式要求：以英文冒号和英文逗号分隔，词语与标点之间不留空格，各词语之间用逗号分隔，最后一个词后不留逗号。 输出示例（词语为例子，非答案）：

2019:改革:10,企业:9,…(略),深化:2 2018:改革:11,效益:7,…(略),深化:1

# 以下代码仅供参考
import jieba

# 处理2019年的数据
fa = open("data2019.txt", "r",encoding='utf-8')  # 打开2019年数据文件
txt = fa.read()  # 读取文件内容
fa.close()  # 关闭文件

# 使用jieba分词，将文本内容切分为词语
words = jieba.lcut(txt)

# 统计词语出现次数，长度为1的词语忽略
d = {}
for word in words:
    if len(word) == 1:  # 忽略长度为1的词语
        continue
    else:
        d[word] = d.get(word, 0) + 1  # 如果词语已存在字典中，计数加1；否则初始化为1

# 将词语和出现次数按出现频率排序，降序排列
lt = list(d.items())
lt.sort(key=lambda x: x[1], reverse=True)

# 输出2019年的前10个词语及其出现次数
print("2019:", end="")
for i in range(10):
    word, count = lt[i]
    if i < 9:
        print("{}:{}".format(word, count), end=",")  # 前9个词后加逗号
    else:
        print("{}:{}".format(word, count))  # 最后一个词后不加逗号

# 处理2018年的数据，流程与2019年相同
fa = open("data2018.txt", "r",encoding='utf-8')  # 打开2018年数据文件
txt = fa.read()  # 读取文件内容
fa.close()  # 关闭文件

# 使用jieba分词，将文本内容切分为词语
words = jieba.lcut(txt)

# 统计词语出现次数，长度为1的词语忽略
d = {}
for word in words:
    if len(word) == 1:  # 忽略长度为1的词语
        continue
    else:
        d[word] = d.get(word, 0) + 1  # 如果词语已存在字典中，计数加1；否则初始化为1

# 将词语和出现次数按出现频率排序，降序排列
lt = list(d.items())
lt.sort(key=lambda x: x[1], reverse=True)

# 输出2018年的前10个词语及其出现次数
print("2018:", end="")
for i in range(10):
    word, count = lt[i]
    if i < 9:
        print("{}:{}".format(word, count), end=",")  # 前9个词后加逗号
    else:
        print("{}:{}".format(word, count))  # 最后一个词后不加逗号

2018-2

请修改编辑器中的代码，完成以下功能：

对比问题1中统计的两组主题词，找出两组共有的词语以及各自特有的词语。 输出格式要求：以英文冒号和英文逗号分隔，词语与标点之间不留空格，各词语之间用逗号分隔，最后一个词后不留逗号。 输出示例（词语为例子，非答案）： 共有词语：改革,…(略),深化 2019特有：企业,…(略),加强 2018特有：效益,…(略),创新

# 以下代码仅供参考
#求2019中的10个主题词，存于da
import jieba
fa=open("data2019.txt","r",encoding='utf-8')
txt=fa.read()
fa.close()
words=jieba.lcut(txt)

d = {}

for word in words:
    if len(word)==1:
        continue
    else:
        d[word]=d.get(word,0)+1

lt = list(d.items())
lt.sort(key = lambda x:x[1],reverse = True)
da={}
for i in range(10):
    da[i]=lt[i][0]

#求2018中的10个主题词，存为db
fa=open("data2018.txt","r",encoding='utf-8')
txt=fa.read()
fa.close()
words=jieba.lcut(txt)

d = {}

for word in words:
    if len(word)==1:
        continue
    else:
        d[word]=d.get(word,0)+1

lt = list(d.items())
lt.sort(key = lambda x:x[1],reverse = True)
db={}
for i in range(10):
    db[i]=lt[i][0]

#求m个共有词存入gy,并将da、db中原共有的改为空
gy={}
m=0
for i in range(10):
    for j in range(10):
        if da[i]==db[j]:
            gy[m]=da[i]
            da[i]=""
            db[j]=""
            m=m+1
            break
print("共有词语:",end="")
for i in range(m):
    if i<m-1:
        print("{}".format(gy[i]),end="")
    else:
        print("{}".format(gy[i]))
        
print("2019特有:",end="")
j=0
for i in range(10):
    if da[i]!="":
        if j<10-m-1:
            print("{}".format(da[i]),end=",")
        else:
            print("{}".format(da[i]))
        j=j+1

print("2018特有:",end="")
j=0
for i in range(10):
    if db[i]!="":
        if j<10-m-1:
            print("{}".format(db[i]),end=",")
        else:
            print("{}".format(db[i]))
        j=j+1
            

是谁偷了我的外卖-1

今天中午，你的外卖被偷了，你一怒之下来到了监控室开始查监控，请修改编辑器中的代码，读入 监控摄像数据.txt 文件中的数据，提取出监控器编号为earpa001的所有数据，并将结果输出保存到earpa001.txt文件。文件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

其中，第一列是监控器获取数据的时间，第二列是监控器的编号，第三列是监控器所在的楼层，第四列是监控器所在的位置区域编号。输出文件的格式要求为：每一行记录与原数据文件保持一致，行尾无空格，无空行。

参考格式：

2016/5/31 7:11, earpa001,2,4 2016/5/31 8:02, earpa001,3,4 2016/5/31 9:22, earpa001,3,4

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

fi=open("监控摄像数据.txt","rb")
fo=open("earpa001.txt","wt")
for line in fi:
    ls=str(line,encoding="utf-8").strip(' \r\n').split(',')
    if ls[1].count("earpa001")>0:
        fo.write('{},{},{},{}\n'.format(ls[0],ls[1],ls[2],ls[3]))
fi.close()
fo.close()

是谁偷了我的外卖-2

经过锁定，你已经列出了你所需要的信息条目，接下来你需要统计监控器在哪些区域运行过了几次来确定小偷所在的宿舍楼层，请修改编辑器中的代码，读入earpa001.txt文件中的数据，统计earpa001对应职员在各楼层和区域出现的次数，并将统计结果保存到earpa001_count.txt文件。文件earpa001.txt的内容格式如下：

2016/5/31 7:11, earpa001,2,4 2016/5/31 8:02, earpa001,3,4 2016/5/31 9:22, earpa001,3,4

其中，第一列是监控器获取数据的时间，第二列是监控器的编号，第三列是监控器所在的楼层，第四列是监控器所在的位置区域编号。统计结果的格式要求为：每条记录占一行，位置信息和出现的次数之间使用英文半角逗号隔开，行尾无空格，无空行。

参考格式：

1-1,5 1-4,3

说明： 第1行1-1,5表示1楼1号区域出现了5次。 第2行1-4,3表示1楼4号区域出现了3次。

# 以下代码为提示框架
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

f=open("earpa001.txt","r",encoding='utf-8')
fo=open("earpa001_count.txt","w")
d = {}
for line in f:
    t=line.strip(' \n').split(',')
    s=t[2]+'-'+t[3]
    d[s]=d.get(s,0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=False) # 该语句用于排序
for i in range(len(ls)):
    a,b=ls[i]
    fo.write('{},{}\n'.format(a,b))
f.close()
fo.close()

中国MOOC-1

考生文件夹下的文件 data.txt 是中国大学 MOOC 平台的某个 HTML 页面源文件，其中包含了一批参与 MOOC 建设的大学或机构列表。

问题1： 请修改编辑器中的代码，从 data.txt 文件中提取大学或机构名称列表，并按大学或机构在 data.txt 中出现的顺序写入文件 univ.txt，每行一个大学或机构名称。

提示： 大学名称在 data.txt 文件中以 alt=“北京大学” 的形式存在。

输出文件示例（univ.txt 内容）：

北京大学 南京大学 …

# 以下代码仅供参考

f=open("data.txt","r",encoding='utf-8')
lines=f.readlines()
f.close()

f = open("univ.txt", "w")
for line in lines:
    if 'alt' in line:  #判断是否有alt,若有则用'alt'分割，分割后再用'"'分割
        dx=line.split('alt=')[-1].split('"')[1]
        f.write('{}\n'.format(dx))
f.close()

中国MOOC-2

考生文件夹下的 univ.txt 文件已包含所有提取出的大学或机构名称，每行一个名称。

任务：

从 univ.txt 文件中提取包含“大学”或“学院”字样的学校名称（不包括“大学生”等字样）。 将所有符合条件的大学名称逐行输出到屏幕，名称之间没有空行。 统计并输出名称中包含“大学”和“学院”的名称数量，分别统计以“大学”和“学院”结尾的名称数量。 输出示例：

北京大学 南京大学 北京师范学院 包含大学的名称数量是2 包含学院的名称数量是1

# 以下代码仅供参考
# 注意：其他已给出代码仅作为提示，可以修改

n = 0
m=0
f = open("univ.txt", "r")
lines=f.readlines()
f.close()
for line in lines:
    if '大学生' in line:
        continue
    elif '大学' in line:
        print('{}'.format(line))
        n+=1
    elif '学院' in line:
        print('{}'.format(line))
        m+=1
    

print("包含大学的名称数量是{}".format(n))
print("包含学院的名称数量是{}".format(m))

八十天环游地球-1

请修改编辑器中的代码，完成以下功能： 从 八十天环游地球.txt 文件中提取所有章节的标题。 将每个提取出的章节标题按顺序写入文件 八十天环游地球-章节.txt，每行一个标题。

输出文件示例（八十天环游地球-章节.txt）： 第一章 斐利亚·福克和路路通建立主仆关系 第二章 路路通认为他总算找到了理想的工作

# 以下代码仅供参考
#可以修改其他代码

# 打开文件读取内容
f = open("八十天环游地球.txt", encoding='utf-8')

# 创建用于存储章节题目的列表
chapter_titles = []

# 遍历文件中的每一行，查找章节题目
for line in f:
    # 假设章节题目形如"第一章"、"第二章"等，正则表达式匹配章节题目
    if line.startswith("第") and "章" in line:
        chapter_titles.append(line.strip())  # 去掉行尾的空白字符

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

# 将提取的章节题目写入新的文件
with open("八十天环游地球-章节.txt", 'w', encoding='utf-8') as output_file:
    for title in chapter_titles:
        output_file.write(title + '\n')  # 每行写入一个章节题目

八十天环游地球-2

请修改编辑器中的代码，完成以下功能： 读取 八十天环游地球.txt 文件中每章节的标题和内容。 统计每章节中出现次数最多的词语（要求词语长度不少于2个字符），并输出每章节的标题、该词语及其出现的次数。

输出格式要求：章节标题、词语及其出现次数，以空格分隔。

输出示例： 第一章 斐利亚 21 第二章 路路通 12

提示：章节标题形如“第一章 斐利亚·福克和路路通建立主仆关系”，章节内容紧随其后。

# 以下代码为提示框架
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换

# 注意：提示框架代码可以任意修改，以完成程序功能为准
import jieba

# 打开文件读取内容
f = open("八十天环游地球.txt", encoding='utf-8')

# 存储每章的标题和内容
chapters = []
current_chapter = None
current_content = []

# 遍历文件内容，按章节分割
for line in f:
    if line.startswith("第") and "章" in line:  # 假设章节题目形如"第一章"、"第二章"
        if current_chapter:
            chapters.append((current_chapter, "".join(current_content)))
        current_chapter = line.strip()
        current_content = []
    else:
        current_content.append(line.strip())

# 添加最后一个章节
if current_chapter:
    chapters.append((current_chapter, "".join(current_content)))

f.close()

# 定义统计词频的函数
def get_most_frequent_word(text):
    words = jieba.lcut(text)  # 使用 jieba 进行分词
    filtered_words = [word for word in words if len(word) > 1]  # 过滤掉长度小于2的词语
    
    # 手动统计词频
    word_freq = {}
    for word in filtered_words:
        if word in word_freq:
            word_freq[word] += 1
        else:
            word_freq[word] = 1

    # 找到最高频的词语
    most_common_word = max(word_freq, key=word_freq.get)
    return most_common_word, word_freq[most_common_word]

# 遍历每个章节并输出高频词
for chapter, content in chapters:
    most_common_word, freq = get_most_frequent_word(content)
    print(f"{chapter} {most_common_word} {freq}")

关键词统计-1

考生文件夹下的 data1.txt 文件包含技术信息资料的内容

请修改编辑器中的代码，完成以下功能：

使用 jieba 库对 data1.txt 文件进行分词。 将长度大于等于3个字符的关键词写入文件 out1.txt，每行一个关键词，关键词不得重复，输出顺序不做要求。

输出文件示例（out1.txt 内容）： 人工智能 科幻小说 机器学习

# 以下代码仅供参考
#
# 注意：其他已给出代码仅作为提示，可以修改

import jieba

# 读取 data.txt 文件内容
with open('data.txt', 'r', encoding='utf-8') as file:
    text = file.read()

# 使用 jieba 对内容进行分词
words = jieba.lcut(text)

# 筛选长度大于等于3的关键词并去重
keywords = set(word for word in words if len(word) >= 3)

# 将结果写入 out1.txt 文件
with open('out1.txt', 'w', encoding='utf-8') as output_file:
    for keyword in keywords:
        output_file.write(keyword + '\n')

关键词统计-2
请修改编辑器中的代码，完成以下功能： 使用 jieba 库对 data.txt 文件进行分词。 对长度不少于3个字符的关键词，统计出现次数，并按出现次数从大到小的顺序写入文件 out2.txt，每行一个关键词及其出现次数，格式为“关键词: 次数”。

输出文件示例（out2.txt 内容）： 科学家:2 达特茅斯:1

# 以下代码仅供参考

import jieba
f=open("data.txt","r",encoding='utf-8')
lines=f.readlines()
f.close()

d = {}
for line in lines:
    wordList=jieba.lcut(line) #用结巴分词，对每行内容进行分词
    for word in wordList:
        if len(word)<3:
            continue
        else:
            d[word]=d.get(word,0)+1
ls=list(d.items())
ls.sort(key=lambda x:x[1],reverse=True)#按照词频由高到低排序
            
f=open('out2.txt','w')
for i in range(len(ls)):
    f.write('{}:{}\n'.format(ls[i][0],ls[i][1]))
f.close()

命运-1

考生文件夹下的 命运.txt 文件是科幻作家倪匡的作品《命运》的文本文件。

请修改编辑器中的代码，完成以下功能：

统计 命运.txt 文件中每个中文字符的出现频次（不包含标点符号）。 输出频次最高的中文字符及其频次，字符与频次之间用英文冒号 : 分隔。 输出示例： 理:224

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

txt=open("命运.txt","r",encoding='utf-8').read()
for ch in"，。？：":
    txt=txt.replace(ch,"")
d = {}
for ch in txt:
    d[ch]=d.get(ch,0)+1
ls=list(d.items())
ls.sort(key=lambda x:x[1],reverse=True)
a,b=ls[0]
print("{}:{}".format(a,b))

命运-2

请修改编辑器中的代码，完成以下功能：

统计 命运.txt 文件中的字符出现频次，不包含回车符。 按频次从高到低的顺序输出前10个频次最高的字符，字符之间无间隔，连续输出。 输出示例： 理斯卫…(后略，共10个字符)

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准

txt=open("命运.txt","r",encoding='utf-8').read()
for ch in '\n':
    txt=txt.replace(ch,"")
d = {}
for ch in txt:
    d[ch]=d.get(ch,0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 此行可以按照词频由高到低排序
for i in range(10):
    print(str(ls[i])[2],end="")

命运-3

请修改编辑器中的代码，完成以下功能： 统计 命运.txt 文件中所有字符的出现频次，字符包含中文、标点、英文等符号，但不包括空格和回车。 将所有字符按频次从高到低排序，并将结果输出到文件 命运-频次排序.txt。字符与频次之间用英文冒号 : 分隔，各字符之间用英文逗号 , 分隔，最后无逗号。

输出文件示例（命运-频次排序.txt 内容）： 理:224,斯:120,卫:100

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 注意：提示框架代码可以任意修改，以完成程序功能为准

txt=open("命运.txt","r",encoding='utf-8').read()
for ch in ' \n':
    txt=txt.replace(ch,"")
d = {}
for ch in txt:
    d[ch]=d.get(ch,0)+1
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 此行可以按照词频由高到低排序
string=""
for i in range(len(ls)):
    s=str(ls[i]).strip("()")
    string=string+s[1]+':'+s[5:]+','
f=open("命运-频次排序.txt","w")
f.write(string)
f.close()

国家新冠统计-1

考生文件夹下的 data301.txt 文件包含2020年5月2日的全球新冠确诊人数统计数据 请修改编辑器中的代码，完成以下功能：

从 data301.txt 文件中提取每个地区的名称和确诊人数。 输出地区的总数，格式示例为“一共有1000个地区”。 将每个地区的名称和确诊人数写入文件 result301.txt，每行一个地区的信息，格式为“地区名称: 确诊人数”。

输出文件示例（result301.txt 内容）： Germany:183979 Thailand:3112 United Kingdom:284868 France:153634

# 以下代码仅供参考


fi = open("data301.txt","r")
f = open("result301.txt","w")
cnumd = {}
name = ''
count = 0
flag = 1
for line in fi:
    if '"name":' in line:
        name = line. split(':')[1].strip()[: -1]
        flag = 1
    elif '"value":' in line and flag == 1:
        dx = line. split(':')[1].strip()
        cnumd[name] = dx
        flag = 0
    count += 1
print("一共有{}个地区".format(count))
for d in cnumd.items():
    f.write("{}:{}\n".format(d[0],d[1]))
print("一共有{}个国家".format(count))
f.close()
fi.close()

国家新冠统计-2

请修改编辑器中的代码，完成以下功能：

读取 result301.txt 文件，对各地区的确诊人数从高到低排序。 输出确诊人数最多的地区名称和确诊人数，格式为“新冠确诊人数最多的地区是 United States, 人数是 1900000”。 统计并输出确诊人数超过1万的地区数量，示例格式为“新冠确诊人数超过1W的地区有20个”。 统计并输出确诊人数为0的地区数量，示例格式为“新冠确诊人数为0的地区有40个”。

# 在____________上补充代码 （12根短线）
# 在……上补充一行或多行代码 （6个点）
#
lcnum = []
with open("result301.txt", "r") as fi:
    for line in fi:
        key, value = line.strip('\n').split(':')
        if value:
            value = int(value)
        else:
            value = 0
        lcnum.append((key.replace('"', ''), value))
lcnum.sort(key=lambda x:x[1], reverse= True)
lz = 0
lw = 0
for l in lcnum:
    if l[1] > 10000:
        lw += 1
    if l[1] == 0:
        lz += 1
print('一共有1084个国家')
print("新冠确诊人数最多的国家是{},人数是{}".format(lcnum[0][0],lcnum[0][1] ))
print("新冠确诊人数超过1W的国家有{}个".format(lw))
print("新冠确诊人数为0的国家有{}个".format(lz))

学院数据库-1

考生文件夹下的 data2.txt 文件包含学生的姓名、班级和分数信息

请修改编辑器中的代码，完成以下功能： 读取 data2.txt 文件，将每位学生的姓名和分数提取出来。 将提取出的信息写入文件 studs.txt，每行记录格式为“姓名:分数”，用英文冒号隔开。 输出文件示例（studs.txt 内容）： 王一:340 李四:150

# 打开并读取 data.txt 文件的内容
with open('data2.txt', 'r',encoding='utf-8') as file:
    lines = file.readlines()

# 提取学生的姓名和分数
students_scores = []
for line in lines:
    # 按照冒号和逗号分割信息
    name, rest = line.split(':')
    _, score = rest.split(',')
    # 添加到列表中
    students_scores.append(f"{name}:{score.strip()}")

# 将提取的信息写入 studs.txt 文件
with open('studs.txt', 'w', encoding='utf-8') as output_file:
    for student in students_scores:
        output_file.write(student + '\n')

print("学生姓名和分数提取完成，结果已保存到 studs.txt 文件中。")

学院数据库-2

请修改编辑器中的代码，完成以下功能： 读取 studs.txt 文件中的学生姓名和分数。 找出分数最高的学生，并将其姓名和分数输出在屏幕上，格式为“姓名:分数”。

输出示例： 李四:450

# 以下代码仅供参考
#初始化数据，将分数设置为一个最小值。
result = ''
score = 0
#读取文件
with open("studs.txt",'r',encoding='utf-8') as f2:
    for line in f2.readlines():
        #截取冒号后面的分数并转为整型数值。
        score_data = int(line.split(':')[1])
        #如果读取的分数比初始值大，则替换。并将整行数据赋值给result。
        if score_data > score:
            score = score_data
            result = line
print(result)

学院数据库-3

请修改编辑器中的代码，完成以下功能： 读取 data.txt 文件中的学生信息。 计算每个班级的平均分，按班级名输出班级和平均分，平均分保留两位小数，用英文冒号隔开。

输出示例： 计算191:447.55 经济191:460.08

# 以下代码仅供参考

#求和字典
sum_dict = {}
#计数字典
count_dict ={}
#结果字典。均值=总和/总次数
result = {}
with open("data2.txt",'r',encoding='utf-8') as f1:
    #循环读取每一行
    for line in f1.readlines():
        #通过字符串截取，获取班级名
        class_name = line[line.find(':')+1:line.find(',')]
        #统计总分，如果不存在该班级，默认为0，此后每次累加分数
        sum_dict[class_name] = sum_dict.get(class_name, 0) + int(line[line.find(',')+1:])
        #统计次数，如果不存在该班级，默认为0，此后每次累加1。
        count_dict[class_name] = count_dict.get(class_name, 0) + 1
        #获取上述结果后，两者相除即可得到均值。用round四舍五入即可得到结果
        result[class_name] = format(round(sum_dict[class_name] / count_dict[class_name], 2), '.2f')


for k,v in result.items():
    print(k+':'+v)

德国工业4.0-1

请修改编辑器中的代码，完成以下功能： 读取 data.txt 文件内容。 对内容进行清理，去掉所有中文标点符号，只保留中文、英文、数字和英文标点符号。 将清理后的内容写入 clean.txt 文件

# 以下代码仅供参考

import jieba
import re
f=open("data3.txt","r",encoding='UTF-8') #文件是utf-8编码
line=f.read()
f.close()

string=re.sub("[(|)|\n|-|！|，|。|？|、|（|）|￥|……|【|】| ]","",line) #line是 utf-8编码，不需要转换。

f=open("clean.txt","w",encoding='UTF-8')
f.write(string)
f.close()

德国工业4.0-2

请修改编辑器中的代码，完成以下功能： 读取 clean.txt 文件内容，提取长度不少于3个字符的词语。 统计每个词语的出现频次，筛选出词频最高的10个词语作为主题词。 将主题词及其出现次数输出到屏幕，格式为“词语:次数”，各词语间用英文逗号分隔，最后一个词语后无逗号。

输出示例： 4.0:10,制造业:9,信息:8,…（略）

# 以下代码仅供参考

import jieba
fa=open("clean.txt","r",encoding='UTF-8')
txt=fa.read()
fa.close()
words=jieba.lcut(txt)



d = {}
for word in words:
    if len(word)<3:
        continue
    else:
        d[word]=d.get(word,0)+1

lt = list(d.items())
lt.sort(key = lambda x:x[1],reverse = True)

for i in range(10):
    word,count=lt[i]
    if i<9:
        print("{}:{}".format(word,count),end=",")
    else:
        print("{}:{}".format(word,count))

成绩榜-1

考生文件夹下的 score.txt 文件记录了某班学生的学号、姓名和10门主干课程的成绩

请修改编辑器中的代码，完成以下功能： 读取 score.txt 文件，计算每位学生的总成绩。 按总成绩从高到低排序，筛选出前10名学生。 将前10名学生的学号、姓名及10门课程成绩写入文件 candidate0.txt，每行一个学生信息，格式与 score.txt 一致。

# 以下代码仅供参考
# 注意：其他已给出代码仅作为提示，可以修改


f=open("score.txt","r",encoding='utf-8')
lines=f.readlines()
f.close()
D=[]  #单个学生的数据
L=[]  #L中的元素是学生原始成绩和总成绩
for line in lines:
    D=line.split()
    s=0  #每个学生的总成绩初始值
    for i in range(10):
        s+=int(D[i+2]) #各科成绩累加求和，+2是因为前两个元素是学号和姓名
    D.append(s)
    L.append(D)

L.sort(key=lambda x:x[-1],reverse=True)   #按学生总成绩从大到小排序
f=open('candidate0.txt','w')
for i in range(10):  #取前十个学生数据
    for j in range(len(L[i])): #一个学生的各项数据
        f.write('{} '.format(L[i][j])) #写各项数据，用空格隔开
    f.write('\n')  #换行
f.close()

成绩榜-2

请修改编辑器中的代码，完成以下功能：

从 candidate0.txt 文件中读取前10名学生的信息。 筛选出所有课程成绩均大于等于60分的学生。 将符合条件的学生学号和姓名写入文件 candidate.txt，每行一个学生，格式为“学号 姓名”。

# 以下代码仅供参考
'''
输入文件 ： candidate0.txt
输出文件 ： candidate.txt
'''
f=open("candidate0.txt",'r')
lines=f.readlines()
f.close()
D=[]
f=open('candidate.txt','w')
for line in lines:
    D=line.split()
    for i in range(10):
        if int (D[i+2])<0:
            break
    else:
        f.write('{}{}\n'.format(D[0],D[1]))
f.close()

有几个曹操-1

考生文件夹下的 data.txt 文件是《三国演义》简介的文本文件

请修改编辑器中的代码，完成以下功能： 使用 jieba 库对 data.txt 文件进行分词。 将分词结果写入文件 out.txt，每行一个词。 输出文件示例（out.txt 内容）： 内容简介 编辑 整个 故事

# 以下代码仅供参考
#
# 注意：请不要修改其他已给出代码

import jieba

# 打开并读取 data.txt 文件的内容
with open('data4.txt', 'r', encoding='utf-8') as file:
    text = file.read()

# 使用 jieba 对内容进行分词
words = jieba.lcut(text)

# 将分词结果写入 out.txt 文件
with open('out.txt', 'w', encoding='utf-8') as output_file:
    for word in words:
        output_file.write(word + '\n')

有几个曹操-2

请修改编辑器中的代码，完成以下功能： 读取 out1.txt 文件内容，统计“曹操”一词的出现次数。 将“曹操”出现的总次数打印输出。

输出示例： 曹操出现次数为:66

# 以下代码仅供参考
# 注意：请不要修改其他已给出代码

import jieba
f = open('out.txt','r',encoding='utf-8')    #以读的方式打开文件
words = f.readlines()
f.close()
D={}
for w in words:        #词频统计
    D[w[:-1]]=D.get(w[:-1],0) + 1
print("曹操出现次数为:{}  ".format(D["曹操"]))

结巴处理-1

考生文件夹下的 data5.txt 文件包含关于商业模式价值链的文本内容

请修改编辑器中的代码，完成以下功能： 使用 jieba 分词库对 data5.txt 文件进行分词。 统计长度不小于2个字符的词语的词频，按词频从高到低的顺序输出前10个高频词。 每行输出一个词语及其词频，词语与词频之间用英文冒号 : 分隔。 输出示例： 我们:5 系统:3 微信:3

# 以下代码仅供参考

import jieba
dict_words = {}
with open('data5.txt', 'r',encoding='utf-8') as f:
    k = jieba.cut(f.read())
for i in k:
    if len(i) >= 2:
        dict_words[i] = dict_words.get(i, 0) + 1
data = sorted(dict_words.items(), key=lambda x:x[1], reverse=True)
print(''.join([k + ':' + str(v) +'\n' for k, v in data[:10]]))

结巴处理-2

请修改编辑器中的代码，完成以下功能： 使用中文逗号和中文句号将 data5.txt 文件内容分割成短句。 查找包含最高词频词语的句子，并将这些句子逐行写入文件 out.txt，每行一个句子。

输出文件示例（out.txt 内容）： 以此为我们吸引更多的商机 同时普及我们的一站式开发技术

# 以下代码仅供参考
#
import jieba
import re
dict_words = {}
with open('data5.txt', 'r',encoding='utf-8') as f:
    senses =  re.sub('([，。\n])', '|' , f.read())
k = jieba.cut(senses)
for i in k:
    if len(i) >= 2:
        dict_words[i] = dict_words.get(i, 0) + 1
data = sorted(dict_words.items(), key=lambda x:x[1], reverse=True)
with open('out.txt', 'w') as f:
    for sense in senses.split('|'):
        if data[0][0] in sense:
            f.write(sense+ '\n')

统计票数-1

考生文件夹下的 vote1.txt 文件记录了每张投票的明星姓名，每行一个投票，只有当行包含一个明星姓名的投票才是有效票。请修改编辑器中的代码,统计并输出 vote.txt 文件中的有效票张数。

示例输出： 有效票50张

# 以下代码仅供参考
# 注意：请不要修改其他已给出代码

f = open("vote.txt",encoding='utf-8')
names = f.readlines()
f.close()
n = 0
for name in names:
    num = len(name.split())
    if num==1:
        n+=1
print("有效票{}张".format(n))

统计票数-2

请修改编辑器中的代码，完成以下功能： 从 vote.txt 文件中读取有效票，并统计每个明星的得票数,输出得票最多的明星姓名及其票数。

示例输出： 最具人气明星为:阿里巴巴,票数为：30

# 以下代码仅供参考
# 注意：请不要修改其他已给出代码

f = open("vote.txt",encoding='utf-8')
names = f.readlines()
f.close()
D = {}
for name in names:
    if len(name.split())==1:
        D[name[:-1]]=D.get(name[:-1],0) + 1
l = list(D.items())
l.sort(key=lambda s:s[1],reverse=True)
name = l[0][0]
score = l[0][1]
print("最具人气明星为:{},票数为：{}".format(name,score))

网页处理-1

考生文件夹下的 webpage.txt 文件保存了某网站的网页 HTML 源代码

请修改编辑器中的代码，统计 webpage.txt 文件中以 .JPG 结尾的图像文件 URL 的数量。 将统计结果打印输出。

示例输出： 输出：15

# 以下代码仅供参考
#读取文件内容到列表ls中
f = open("webpage.txt","r",encoding='utf-8')
ls=f.readlines()
f.close()
#统计url个数
num= 0  #统计个数的初始值为0
for line in ls:
    if "img" in line:
        url=line.split("src=")[-1].split('"')[1] #用"src="分割，再用“"”分割，其中序号为1的元素就是url本身
        if "http" in url:  #确定是图片链接
            num = num+1  #统计个数
print(num)  #输出个数

网页处理-2

请修改编辑器中的代码，完成以下功能：
从 webpage.txt 文件中提取所有 .JPG 结尾的图像文件 URL。
将提取出的每个 URL 写入文件 images.txt，每行一个 URL。

输出文件示例（images.txt 内容）：
http://image.ngchina.com.cn/2018/0829/20180829012548753.JPG
http://image.ngchina.com.cn/2018/0823/thumb_469_352_20180823121155508.JPG

# 以下代码仅供参考

f = open("webpage.txt","r",encoding='utf-8')
ls = f.readlines()
f.close()
jpgurl = []   #定义空列表
for line in ls:
    if "img" in line:
        url = line.split("src=")[-1].split('"')[1]
        if "http" in url:
            jpgurl.append(url)  #将url追加到列表中
f=open("images.txt","w")
for url in jpgurl:
    f.write(url+"\n")  #添加换行符
f.close()

论语-1

考生文件夹下的 论语.txt 文件包含《论语》内容，文件结构采用逐句“原文”与逐句“注释”相结合的形式

请修改编辑器中的代码，完成以下功能： 从 论语.txt 文件中提取所有【原文】标签后的内容，去掉标签，仅保留原文内容。 去除每行行首和行尾的空格，确保无空行，并将结果输出保存到 论语-原文.txt 文件中。 保留原文中的小括号及内部数字，以符合格式要求。

输出文件示例（论语-原文.txt 内容）： 子曰：“学而时习之，不亦说乎？有朋自远方来，不亦乐乎？人不知，而不愠，不亦君子乎？”

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准


fi = open("论语.txt", "r",encoding='utf-8')
fo = open("论语-原文.txt", "w",encoding='utf-8')
a=0
for line in fi:
    if a==1 and line.count("【注释】")==0 and line.count("【原文】")==0:
        line = line.strip(" \n")
        if line.strip():#判断line是否为空串
            fo.write('{}\n'.format(line))
    if line.count("【原文】")>0:
        a=1
    if line.count("【注释】")>0:
        a=0
fi.close()
fo.close()

论语-2

请修改编辑器中的代码，完成以下功能： 从 论语-原文.txt 文件中读取《论语》原文内容。 去掉每行文字中的小括号及内部数字。 将结果保存到文件 论语-提纯原文.txt 中，确保无空行。

输出文件示例（论语-提纯原文.txt 内容）： 子曰：“学而时习之，不亦说乎？有朋自远方来，不亦乐乎？人不知，而不愠，不亦君子乎？”

# 以下代码仅供参考
# 请在...处使用一行或多行代码替换
# 请在______处使用一行代码替换
#
# 注意：提示框架代码可以任意修改，以完成程序功能为准


fi = open("论语-原文.txt", "r",encoding='utf-8')
fo = open("论语-提纯原文.txt", "w",encoding='utf-8')
for line in fi:
    for k in range(100):#可以打开给定文件看一下最大值
        line=line.replace('('+str(k)+')','')
    fo.write(line)
fi.close()
fo.close()