Python编程考试题库

在一次数学竞赛中，A、B、C、D、E五名同学分别获得了前五名（假设无并列名

次）。小敏问他们分别是第几名，他们的回答如下。

・A:第二名是D,第三名是B。第二名是C,第四名是E。・C:第一名是E,

第五名是A。・D:第三名是C,第四名是A。・E:第二名是B,第五名是D。.

但他们每个人都只说对了一半,请编写程序,帮小敏猜一猜他们的真实名次。

['E','C','B','A','D']

某幼儿园组织秋游，需要统计人数。假设字典dic_class存放了幼儿园所有的

班级，内容为

{〃托班〃：[〃聪聪班〃，〃伶伶班〃，〃楠楠班〃

字典dic_number存放了每个班的报名人数，内容为

{〃聪聪班〃：26,〃伶伶班”：23,〃楠楠班〃：25,

试编写程序,统计各年级报名人数以及全园报名总人数。

输出结果如下:托班:74人小班:63人中班:67人大班:65人全园:269人

dic_class={"tuoban":["congcongban","linglingban","nannanban"],"xiaoba

n:Lxiaoyiban,xiaoerbanJ,zhongban:Lzhongyiban,zhongerbanJ,

daban〃：[〃dayiban〃，〃daerban〃]}

dic_number={^congcongban77:26,z/linglingban/z:23,“nannanban”:25,"xiaoyib

an，z:32,“xiaoerban”:31,"zhongyiban”:

33,“zhongerban”:34,〃dayiban〃：32,〃daerban〃:33}

dic_totle={}

fork,vindic_class.items():

s=0

forxinv:

s+=dic_number[x]

dic_totle[k]=s

fork,vindic_totle.items():

print(/z{}:{}〃.format(k,v))

print("All:{}〃・format(sum(dic_totle.values())))

新建一个文本文件zen.txt,文件内容为“Python之禅”的部分内容，具体如

下：

Beautifulisbetterthanugly.

Explicitisbetterthanimplicit.

Simpleisbetterthancomplex.

Complexisbetterthancomplicated.

编写程序统计该文件内容的行数及单词的个数。

withopen('zen.txt',〃r〃，encoding='utf-8')asfile:

content=file,readlines()

words=[len(row[:-l].splitO)forrowincontent]

print(f'行数：{len(content)}')

print(f，单词的个数：{sum(words)}')

已知字符串s存放了一个英文绕口令

s=z/Whethertheweatherbefine,orwhethertheweatherbenot.Whether

theweatherbecold,orwhethertheweatherbehot.Wewillweatherthe

weatherwhetherwelikeitornot.〃

试编写程序，统计该字符串中英文单词的个数(不区分大小写且不能重复)。

s=input(///z)

s=s.lower().replacereplace

lst=s.split(，')

wordSet=set(1st)

print(wordSet)

print(Z/Thereare{}wordsintotal./z.format(len(wordSet)))

分别输入直角三角形的两个直角边长，求斜边的长度、周长和面积并输出

假设边长为实数，结果保留2位小数并输出

sidel=eval(input())

side2=eval(input())

side3=pow(sideInside1+side2*side2,1/2)

length=sidel+side2+side3

area二sidel*side2/2

print(〃{:.2f}〃.format(side3))

print(〃{:・2f}〃・format(length))

print(〃{:.2f}〃.format(area))

使用程序计算整数N到整数N+100之间所有奇数的数值和，不包含N+100,

并将结果输出

整数N由用户给出，不判断输入异常。

N=input(〃请输入一个整数：〃)

s=0

foriinrange(eval(N),eval(N)+100):

ifi%2=1:

s+=i

print(s)

编写一个函数进行重复元素的判定，接收一个列表作为参数，如果一个元素在列

表中出现了不止一次，则返回True,否则返回False,注意处理过程中不要改变

原列表的值。

主程序中调用该函数判定用户输入的列表中是否有重复元素

例如用户输入［87,34,35,26,75,72］则程序应该输出False

deffun(ls):

forninIs:

ifIs.count(n)>1:

returnTrue

else:

returnFalse

deffun2(Is):

returnlen(set(Is))<len(ls)

Is=eval(input('请按照列表格式输入列表元素：’))

iffun(ls)==True:

print(，Thereareduplicateelementsinthislist，)

else:

print(JTherearenoduplicateelementsinthislist，)

iffun2(Is)==True:

print('该列表中存在重复元素')

else:

print('该列表中不存在重复元素')

新建〜个文本文件yzy.txt,文件内容如下：

慈母手中线，游子身上衣。临行密密缝，意恐迟迟归。谁言寸草心，报得三春晖。

编写程序输出该文件的内容，要求使用一次性读入整个文件内容和逐行读取文件

内容两种方式。

file=open('yzy.txt','r',encoding='utf-8')

print(file,read())

file,close()

file=open(，yzy.txt),'r',encoding='utf-8')

print(file,readline())

print(file,readline())

print(file,readline())

print(file,readline())

file,close()

假设已有字典变量dic_score存储了学生的成绩信息（见下表），r姓名为字典

的键。

试编写程序，统计每名学生的平均成绩，添加至字典，最后将字典内容输出。

语数英计算

姓名

文学语机

XuLi88909895

ZhangXing85929598

LiuNing89899092

ZhangXu82868990

dic_score={，，XuLi/，:[88,90,98,95],"ZhangXing〃：[85,92,95,98],“LiuNing〃：]

89,89,90,92],"ZhangXu":[82,86,89,90]}

fork,vindic_score.items():

dic_score[k].append(sum(v)/len(v))

print(〃Name\tChinese\tMath\tEnglish\tComputer\tAverageScore")

fork,vindic_score.items():

print(k,end=〃\t〃)

forxinv:

print(x,end=〃\t〃)

print()

输入一个8位整数，将其中四位取出来输出

num=eval(input())

print(num//100%10000)

警察抓了abed四个盗窃嫌疑犯其中只有一个人是小偷,

请问到底谁是小偷？

C

找出2〜100中所有的李生素数。李生素数是指相差2的素数对，如3和5、5

和7、n和13等。

(3,5)

(5,7)

(11,13)

(17,19)

(29,31)

(41,43)

(59,61)

(71,73)

文件goods,txt中每-行内容分别为购买的商品名称、价格、数量，内容如下：

apple103

focus1000001

surface80002

thinkpad70003

chicken103

求出所购商品花费的总费用。

cost=[]

withopen(Jgoods.txt，,'r')asfile:

forrowinfile,readlines():

Is=row.split('')

cost,append(int(ls[l])*int(ls[2]))

print(sum(cost))

新建--个文本文件score,csv,用来保存10名考生3门课程的成绩，内容如下:

考号，程序设计，细胞生物，生理学

10153450101,72,96,88

10153450102,68,88,73

10153450103,63,63,66

10153450104,95,64,65

10153450105,89,88,57

10153450106,77,87,77

10153450107,67,64,97

10153450108,44,99,64

10153450109,82,73,75

10153450110,79,78,85

以上各数据项均使用英文逗号分隔。

请编写程序读取该文件内容，统计每门课程的平均分、最高分、最低分

#统计score.CSV文件中每门课程的平均成绩、最高分和最低分。

#方法一

withopenCscore,csv',"r",encoding=，utf-8")asfile:

LS=list(file)

delLS[O]#去掉标题行

Isl,ls2,ls3=□,□,[]

forsinLS:

X=s[:T].split#因为最后一个字符是回车符\n,s[:T]相当于

去掉了最后的回车符

Isl.append(int(x[l]))

ls2.append(int(x[2]))

ls3.append(int(x[3]))

print('程序设计课程平均成绩：｛:.2f｝,最高分｛｝,最低分｛｝'.format(sum(lsl)

/len(lsl),max(Isl),min(lsl)))

print(J细胞生物课程平均成绩：｛:.2f｝,最高分｛｝,最低分｛｝'.format(sum(ls2)

/len(ls2),max(ls2),min(ls2)))

print('生理学课程平均成绩:｛：.2打，最高分｛｝,最低分｛｝'.代皿1@土於11111(卜3)/

len(ls3),max(ls3),min(ls3)))

#方法二，使用内置csv库和字典读法

importcsv

Isl,ls2,ls3=[],[],[]

withopen(，score.csv，,〃r〃，encoding='utf-8')asfile:#用with打开

文件，可以不用去特意关闭file了

reader=csv.DictReader(file)

forrowinreader:

#print(row)

Isl.append(int(row[〃程序设计〃[))

ls2.append(int(row[〃细胞生物〃]))

Is3.append(int(row]〃生理学〃]))

print('程序设计课程平均成绩：{:.2f},最高分{},最低分{}'.format(sum(lsl)

/len(lsl),max(Isl),min(lsl)))

printC细胞生物课程平均成绩：{:.2f},最高分{},最低分{}'.format(sum(ls2)

/len(ls2),max(ls2),min(ls2)))

print('生理学课程平均成绩：{：.2f},最高分。，最低分{『.format(sum(ls3)/

len(ls3),max(ls3),min(ls3)))

读取任意一个Python源代码文件(・py文件)在源代码每行的左边加上行号，且

行号与代码间保留-个空格，最后将含有行号的代码保存至一个新的文件内。

withopen('实验9-9.py',〃r〃，encoding='utf-8')asfile:

lines=file,readlines()

Is=[str(i+1)+''+linefori,lineinenumerate(lines)]

new_content=''.join(Is)

print(new_content)

withopen('实验9-9_带行号.txt',〃w〃，encoding='utf-8')asfile:

file,write(newcontent)

编写程序，对用户输入的英文字符串中各字母出现的次数进行统计(不区分大写

字母和小写字姆)，统计结果使用字典存放。

例如，字符串Ihave2ideas.的统计结果为

2,'h':1,:2,'v':1,，e，:2,'d':1,'s':1)

myDict={}

forcins:

ch=c.lower()

ifch.isalphaO:

myDict[ch]=myDict.get(ch,0)+1

print(myDict)

反弹的球

球从100米高度自由落下，每次落地后反跳回原高度的一半。求它在第n次落地

并反弹回时，共经过多少米？

n由用户输入，结果要求保留2位小数

s=0

h=100

n=int(input())

for_inrange(1,n+1):

s+=(h+h/2)

h/=2

print(〃{:.2f}〃.format(s))

定义一个函数delSame(li),参数li是一个列表(普通列表，不包含嵌套的子列

表)；该函数返回一个新列表，新列表不包含重复元素，只保留第一-次在原列

表中出现的元素。

如原列表为[1,2,3,4,5,2,1,4,5,3,8,8,9],经过处理后得到的列表为[1,

2,3,4,5,8,9]。在主程序中定义一个列表并初始化，调用该函数，输出

新的列表。

importrandom

defdelSame(ls):#此方法可以保持元素的原始顺序

t=[]

forpinIs:

ifpnotint:

t.append(p)

returnt

defdelSame2(Is):

returnlist(set(Is))#使用集合去重，但不能保持元素的原始顺序

data=[random,randint(1,100)foriinrange(12)]

print(data)

print(delSame(data))

print(delSame2(data))

data=[1,2,3,4,5,2,1,4,5,3,8,8,9]

print(data)

print(delSame(data))

print(delSame2(data))

对于学生成绩，学生关注的通常是自己的成绩，而教师往往关注的是全班成绩。

现在有一个字典(键为学号，值为成绩)，里面存放若干名学生的成绩，如

{"9601”:95,"9602":96,"9603”:87,,其中“9601”表示学号，95表示成

绩。

请编写一个程序，要求如下：

1.定义一个全局字典，用来保存学生的成绩

2.定义一个函数，接收一个参数，该参数表

示学号，函数返回字典中该学号对应的成绩。若字典中不存在该学号，则函数返

回T。

3.定义一个函数，按照成绩降序输出所有学

生信息,例如：

9602,96

9601,959603,87

在主程序中测试这两个函数。

dicScore={

'9601':95,

‘9602':96,

‘9603):87,

}

defget_score(id):

returndicScore.get(id,-1)

defsortscore():

Is=sorted(dicScore.items(),key=lambdax:x[l],reverse=True)

foriinIs:

print(f){i[0]},)

print(get_score('9602"))

sort_score()

编写程序输入梯形的上边长、下边长和高计算梯形的面积并输出，输出结果保留

两位小数

top=eval(input())

bottom=eval(input())

height=eval(input())

area=(top+bottom)*height/2

print.2f}format(area))

微信朋友圈中曾疯传“手机尾号暴露你的年龄”，其算法如下：

1.看一下你手机号的最后一位;2.把这个数字乘以2;

3.然后加上5;

4.再乘以50;

5.把得到的数加上1766;

6.用这个数减去你出生的那一年；

现在得到一个新的数字，该数字的最后两位就是你的实际年龄(本规则仅适用于

年龄在100岁以内的人)。

现在，请编写一个函数来实现上述计算，该函数有两个参数:一个参数为手机号

最后一位;另一个参数为四位数的出生年份，如1990。该函数最后返回按照上述

规则计算出来的年龄。在主程序中让用户输入手机号最后一位和出生年份，调用

该函数输出计算结果。

deffun(m,n):

return((m*2+5)*50+1766-n)%100

m=int(input('请输入手机号最后一位：’))

n=int(input('请输入四位出生年份：’))

print(fun(m,n))

定义一个lambda。函数用来求一个数的平方，然后调用该函数求出一个列表所

有元素的平方之和。

importrandom

fun=lambdan:n**2

data=[random,randint(1,10)foriinrange(5)]

print(data)

data2=[fun(d)fordindata]

print(sum(data2))

某文件data,txt中存放了若干个整数，各整数之间使用英文逗号分隔，编写程

序读取该文件中的所有整数，将其升序排列后保存至一个新的文件内。

withopenC9-12.txt',"r",encoding=，utf-8))asfile:

content=file,read()

data=[int(d)fordincontent,split(',')]

data,sort()

new_content=join([str(d)fordindata])

print(new_content)

withopenC9-12_sort.txt',"w",encoding=，utf-8")asfile:

file,write(new_content)

输出[m,n]范围内的所有素数

其中m和n由用户输入，假设m<=n,且二者均大于1

输出时素数之间以单一英文空格分割

例如：

用户输入2,10

输出2357

m,n=eval(input())

foriinrange(m,n+1):

forjinrange(2,i):

ifi%j==0:

break

else:

print(i,end=，')

文件score,txt保存了学生的平时成绩和期末成绩，内容如下：

学号,平时成绩,期末成绩

9999180101,77,88

9999180102,91,85

9999180103,87,96

9999180104,78,68

9999180105,86,72

编写程序读取所有成绩，计算总评成绩(四舍五入到整数)，其中总评成绩=平时

成绩X40%+期末成绩X60虬最后按总评成绩降序排列后保存至一个新的文件

内，文件内容应该如下：

学号，平时成绩，期末成绩，总评成绩

9999180103,87,96,92

999918el02,91,85,87

9999180101,77,88,84

9999180105,86,72,78

9999186104,70,68,69

importcsv

withopen('score,txt"r",encoding=，utf-81)asfile:

data=list(csv.reader(file))[1:]#去除标题行

print(data)

fordindata:

d.append(str(round(int(d[1])*0.4+int(d[2])*0.6)))

print(data)

data,sort(key=lambdax:x[3],reverse=True)

data,insert(0,['学号'，'平时成绩'，'期末成绩‘，'总评成绩'])

#print(data)

withopen(，score_total.txt',〃w〃，encoding='utf_8,,newline='')as

file:

writer=csv.writer(file)

writer,writerows(data)

#另一种方法，使用DictReader和DictWriter,可读性较好

withopen(，score,txt〃r〃，encoding='utf-8')asfile:

data=list(csv.DictReader(file))#DictReader并不包含第一行标题

■

fordindata:

#print(d)

d['总评成绩']=str(round(int(d「平时成绩'])*0.4+int(d['期末成

绩'])*0.6))

print(d)

data,sort(key=lambdad:d['总评成绩reverse=True)

#print(data)

#fordindata:

#print(d)

fieldnames='学号'，’平时成绩'，'期末成绩'，'总评成绩']

withopen(，score_total.txt〃w〃，encoding='utf-8',newline」')as

file:

writer=csv.DictWriter(file,fieldnames)

writer,writeheader()

writer,writerows(data)

用代码创建如下加密字典die,键为26个小写英文字符，值为该字符对应的下

一个字符，最后一个字符：对应的为a

die={a:b,b:c,c:d,...z:

然后利用该字典将用户输入的一个小写英文句子转换为对应的加密句子(其它字

符不予加密

例如hellopython加密后为ifmmpqzuipo

die二{}

forcinrange(ord('a'),ord('z')):

die[chr(c)]=chr(c+1)

dieLzJ=a

old=input(zzplsinputurstring:")

〃〃

new=

forcinold:

if(c>=，a'andc<='z'):

new+=dic[c]

else:

new+=c

print(new)

输入期末、作业和平时成绩计算总成绩

最终成绩由期末考试成绩，作业成绩和平时成绩构成，三类成绩满分均为100

分，占最终成绩的比重为：0.6,0.3和0.1,请编程分别输入三类成绩，计算并

输出最终成绩，结果保留到小数点后1位。

例如输入：

80

80

80

输出：80

term=eval(input())

homework=eval(input())

regular=eval(input())

final=term*。.6+homework*0.3+regular*0.1

printIf}format(final))

中位数是常见的统计量之一，在概率论和统计学中有广泛的应用，在偏态分布中

有重要的价值。

例如，想从一组数据中知道人们的平均财富，假设100人一个月每人收入100

元，10人一

个月每人收入1000000元。如果兽平，1行到的是91000元，这是一个元全没有

P人1示真实情况的奇怪的值。在这种境死T姜数会提供更有用的值和较好的通

25公卖个数不同的列表而言，中位委T导-P如下两种：

1.若列表中元素的个数为奇数，则中位数为排序后列表中间位置的那个数。

2.若列表中元素的个数为偶数，则中位数为排序后列表中间位置两个数的平均

值。请编写一个函数，该函数接收一个列表参数，返回该列表的中位数，最后在

主程序中测试该函数。

importrandom

defmedian(Is):

_ls=sorted(Is)

_len=len(_ls)

if_len%2二二0:

return(_ls[_len//2-1]+_ls[_len//2])/2

else:

return_ls[_len//2]

data=[random,randint(1,100)foriinrange(5)]

print(sorted(data))

print(median(data))

data=[random,randint(1,100)foriinrange(6)]

print(sorted(data))

print(median(data))

输入m和n计算m*(m+1)*(m+2)*...*n的积

如果m>n则输出0

例如

输入2,5则输出120

输入3,8则输出20168

输入649,319则输出e

m,n=eval(input())

r=0

ifm>n:

pass;

else:

r=1

foriinrange(m,n+1):

r*二i

print(r)

编写一个函数isdiff(n),用来判断参数n的各位数字是否互不相同，若互不相

同，则返回1否则返回3主程序中调用该函数对用户输入的数据进行判断并输

出结果。

defisdiff(n):

s=str(n)

foriins:

ifs.count(i)>1:

return0

else:

return1

defisdiff2(n):

a=str(n)

b=set(a)

return1iflen(a)==len(b)else0

n=int(input('请输入一个正整数：’))

ifisdiff(n)==1:

print(f?Thedigitsof{n}aredifferentfromeachother，)

else:

print(f，Thereareduplicatefiguresin{n}')

ifisdiff2(n)二二1:

print(f'{n}的各位数字互不相同’)

else:

print(f'{n}中有重复数字')

编写一个函数isdiff(n),用来判断参数n的各位数字是否互不相同，若互不相

同，则返回1否则返回0,主程序中调用该函数对用户输入的数据进行判断并输

出结果。

s=int(input('请输入成绩：’))

ifs>=90:

grade='A'

elifs>=60:

grade='B'

else:

grade='C'

print(grade)

求出所有符合下列条件的三位正整数:分别乘以3、4、5、6、7后得到的整数的

各位数字之和都相等。

例如：

x=180:x*3=540,x*4=720,x*5=90e,x*6=10x=198:x*3=594,x*4=792,

x*5=990,x*6=11

deffun(n):

Is=[int(c)forcinstr(n)]

returnsum(ls)

count=0

forninrange(100,1000):

iffun(n)==fun(n*3)==fun(n*4)二二fun(n*5)==fun(n*6)==

fun(n*7):

count+=1

print(fz/x={n}:x*3={n*3},x*4={n*4},x*5={n*5},x*6={n*

6},x*7={n*7}〃)

输出1+2+3+..・+n的和超过max的第一个和及此时的求和项的数量

其中max由用户输入，输出的两个数据使用单个空格分割

例如：

输入5

则输出63

max=eval(input())

sum=0

i=1

whilesum<=max:

sum+=i

i+=1

else:

print(sum,i-l)

编写一个函数，简单模拟微信发红包算法。

函数有两个参数:一个参数表示红包总金额，默认值为100;另一个参数表示红包

数量，默认值为15。

所有随机产生的红包金额(保留两位小数)存放在一个列表(同时作为函数的返回

值)中，单个红包金额最少为0.01元，所有红包金额之和应等于红包总金额。

最后在主程序中调用该函数模拟发红包过程。

importrandom

defredPacketl(money=100,number=15):

Is=[]

forninrange(number-1):

lucky_money=random,uniform(0.01,money-(number-1-n)*

0.01)

lucky_money=round(lucky_money,2)

Is.append(lucky_money)

money=money一lucky_money

Is.append(round(money,2))

returnIs

defredPacket2(money=100,number=15):

Is=[]

forninrange(number-1):

lucky_money=random,uniform(0.01,money/(number-n)*2)

lucky_money=round(lucky_money,2)

Is.append(lucky_money)

money=money-lucky_money

Is.append(round(money,2))

returnIs

defredPacket3(money=100,number=15):

money=money*100

Is=[]

forninrange(number-1):

lucky_money=random,randint(1,int(money/(number-n)*2))

Is.append(lucky_money/100)

money=money一lucky_money

Is.append(money/100)

returnIs

a=redPacketl()

print(a)

print(sum(a))

a=redPacket2()

print(a)

print(sum(a))

a=redPacket3()

print(a)

print(sum(a))

a=redPacket3(1000)

print(a)

print(sum(a))

a=redPacket3(1000,20)

print(a)

print(sum(a))

a=redPacket3(10,6)

print(a)

print(sum(a))

#money=float(input('红包总金额：’))

#number=int(input('红包数量：'))

#print(redPacket(money,number))

计算运动会某个参赛选手的得分。假设共有10个裁判，每个裁判给该参赛选手

打分（分值在0〜10之间）后，去掉一个最高分和一个最低分之后的平均分即

为该运动员的最后得分。

某位选手的得分数据保存在文件中，各数据之间使用一个空格分隔，内容如下:

9.379.529.98109.859.739.939.769.819.08

请编写程序从文件中读取该选手的成绩并计算最后得分。

file=open('9-2.txt','r',encoding='utf-8')

content=file.read()

file,close()

scores=[float(n)fornincontent.split()]

print(scores)

maxScore=max(scores)

minScore=min(scores)

scores,remove(maxScore)

scores,remove(minScore)

print(scores)

print(sum(scores)/len(scores))

某超市整理库存。假设字典dic_repertory存储了超市最初的商品数量。

dic_repertory={〃SoySauce〃：50,“Vinegar”:60,"Salt”:100,“Sugar”:120,〃Chi

ckenEssence〃：20,“Sesame0il〃：40}

字典dic_change存储了经过销售和进货等流程后发生变化的商品及其现有数

量。

dic_change={〃SoySauce”:100,“Vinegar”:80,"ChickenEssence”:50,"Oyster

Sauce”:60}

试编写程序，实现以下功能：

1.对字典dic_repertory的内容进行更新。

2.对更新后的字典dic_repertory按照商品数量进行降序排列。

3.输出当前库存数量最多的商品和最少的商品信息。

dic_repertory={z/SoySauce/z：50,z/Vinegarz/：60,/zSalt/z:100,Z/Sugar/Z:120,Z/Chi

ckenEssence〃：20,“Sesame0il〃:40}

dic_change={^SoySauce〃：100,“Vinegar”:80,"ChickenEssence〃：50,“Oyster

Sauce”:60}

dic_repertory.update(dic_change)

dic_result=sorted(zip(dic_repertory.values(),dic_repertory.keys()),re

verse=True)

print(z，Thegoodswiththemaximuminventoryare:

{}〃.format(dic_result[0][1]))

print(Z/Thegoodswiththeleastinventoryare：

{}〃.format(dic_result[-1][1]))

输入一个三位数，求各位数字之和并输出

例如输入123,输出6

num=eval(input())

print(num//100+num//10%10+num%10)

使用循环结构计算x的n次幕

输入两个整数x和n,计算x的n次塞并输出，如果n为O则输出1

x,n=eval(input())

r=1

foriinrange(1,n+1):

r=r*x

print(r)

编写程序随机产生100个两位正整数，并将这100个数写入文本文件

number,txt中，要求每行10个整数，整数之间用一个空格分隔。

importrandom

data=[random,randint(10,100)foriinrange(100)]

withopen(，number.txt，,〃w〃，encoding='utf-8')asfile:

k=0

fordindata:

file,write(str(d)+')

k=k+1

ifk%10==0:

file,write('\n')

zen.txt文件内容如下：

Beautifulisbetterthanugly.

Explicitisbetterthanimplicit.

Simpleisbetterthancomplex.

Complexisbetterthancomplicated.

请编写程序统计文件内单词的词频，并将统计结果保存至一个新的文件内。词频

即相同单词出现的次数，如zen.txt文件中better的词频为4,Simple的词

频为lo

withopen('zen.txt',〃r〃，encoding='utf-8')asfile:

content=file.read().lower().replace(，\n，,'')・replace'')

words=content,split()

dic_fq={}

forwordinwords:

dic_fq[word]=dic_fq.get(word,0)+1

forfqindic_fq.items():

print(f){fq[0]):{fq[l]}?)

#另一种方法：使用collections库中的Counter,更简洁

fromcollectionsimportCounter

printC-----------')

result=Counter(words)

forrinresult,items():

print(ff{r[0]}:{r[1])，)

分数转换，读取百分制分数并转换成对应的字符输出

学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C

表示

s=int(input('请输入成绩:'))

ifs>=90:

grade='A'

elifs>=60:

grade='B'

else:

grade='C'

print(grade)

编写函数求s=a+aa+aaa+.・.十aaa...aaa的值,其中a是1~9之间的某

个数字，n是一个正整数。

例如，当a=2,n=5时，8=a+aa+aaa+...+aaa...aaa=24690。

主程序中根据用户输入的a和n调用该函数计算结果并输出。

deffun(a,n):

s=0

item=0

foriinrange(n):

item=item*10+a

s+=item

returns

deffun2(a,n):

s=0

foriinrange(1,n+1):

s+=int(str(a)*i)

returns

deffun3(a,n):

Is=[int(str(a)*i)foriinrange(1,n+1)]

returnsum(ls)

a,n=eval(input(〃输入a和n[用逗号分隔]:〃))

s=fun(a,n)

print(f"ifa={a},n={n},s=a+aa+aaa+...+aaa...aaa={s}〃)

s=fun2(a,n)

print(f〃若a={a},n={n},贝!]s=a+aa+aaa+...+aaa...aaa={s}z/)

s=fun3(a,n)

print(f〃若a={a},n={n},贝！Js=a+aa+aaa+...+aaa...aaa={s}")

假设字典dic_score存放了学生的成绩，内容为

{〃李刚〃:93,〃陈静〃：78,〃张金柱〃：88,〃赵启山〃：91,〃李鑫〃：65,〃黄宁

〃：83)

试编写程序，按成绩从高到低的顺序输出学生的姓名。

dic_score={“LiGang〃:93,〃ChenJing〃:78,〃ZhangJinzhu〃:88,“ZhaoQishan〃:91

,〃LiXin〃:65,〃HuangNing〃:83}

1st_name=dic_score.keys()

lst_score=dic_score.values()

dic=zip(lst_score,lst_name)

forxinsorted(die,reverse=True):

print(x[l])

编写一个程序，在主程序中求1900~2020年中所有的闰年，每行输出5个年份。

闰年即能被4整除但不能被100整除，或者能被400整除的年份。

要求定义一个函数isLeap(),该函数用来判断某年是否为闰年，是闰年则函数

返回True,否则返回Falseo

defisLeapYear(year):

returnyear%400==0or(year%4==0andyear%100!=0)

count=0

forninrange(1900,2021):

ifisLeapYear(n)isTrue:

print(n,end='\t')

count+=1

ifcount%5==0:

print()

输出满足勾股定理的20以内的所有组合勾股定理中3个数的关系是

:gou-2+gu-2=Xian^2,编写一个程序，输出20以内(包括20)满足上述条件且

gou<gu的整数组合，如345就是符合条件的一个组合

0

要求每个组合中三个数据以空格分割，每个组合单独一行，形如：

345

51213

6810

forgouinrange(1,21):

forguinrange(1,21):

forxianinrange(1,21):

ifgou*gou+gu*gu==xian*xianandgou<gu:

print(gou,gu,xian)

编写程序，对用户输入的英文字符串中各字母出现的次数进行统计(不区分大写

字母和小写字母)，统计结果使用字典存放。

例如，字符串Ihave2ideas.的统计结果为

{'『：2,〃h':1,〃a':2,〃v:1,'e':2,'d':1,'s':1}

myDict={}

forcins:

ch=c.lower()

ifch.isalpha():

myDict[ch]=myDict.get(ch,0)+1

print(myDict)

编写一个函数，接收一个列表参数，函数返回该列表中所有正数之和。

在主程序中调用该函数计算用户输入的一个整数列表中正数的和并输出。

例如用户输入：[23,54,77,87,56,3]

程序应该输出30日

deffun(Is):

_ls=[iforiinIsifi>0]

returnsum(_ls)

deffun2(Is):

_ls=filter(lambdan:n>0,Is)

returnsum(_ls)

Is=eval(input(请按照列表格式输入列表元素：’))

print(f'Thesumofallthenumbersinthislistis:{fun(Is)},)

print(F该列表中所有正数之和为：{fun2(ls)}‘)

假设字典变量dic_country存储了部分国家的国家名与首都名的对应关系，其中

国家名为键首都名为值，如下表。

试编写程序，根据用户输入的国家名查询首都名，如果存在则输出查询结果，否

则提示

“None"。假设对国家名进行查询时不区分大小写。

dic_country={"China":"Beijing","America":"Washington","Norway":"Oslo"

,〃J丁apan〃:〃Tloikyo〃,〃△Germany〃:〃nBerliin,”Ccanadia〃:〃O八t」t,awa〃,〃b「rance〃:〃Pcari•s

〃,“Thailand":"Bangkok”}

country=input(〃请输入国家名：〃).lower().capitalize()

ifcountryindic_country:

print(dic_country[country])

else:

print(〃None〃)

已知字符串变量

s="Wheninthecourseofhumanevents,itbecomesnecessaryforonepeople

todissolvethepoliticalbandswhichhaveconnectedthemwithanother,

andtoassumeamongthepowersoftheearth,theseparateandequalstation

towhichtheLawsofNatureandofNature5sGodentitlethem,adecent

respecttotheopinionsofmankindrequiresthattheyshoulddeclarethe

causeswhichimpelthemtotheseparation.〃

试编写程序，实现以下功能：

1.对文本中每个单词出现的次数进行统计，并将结果输出。

2.输出出现次数排在前五名的单词

s=input(〃〃)

s=s.lower().replacereplace

lst=s.splitC')

dic={}

forwordin1st:

die[word]=dic.get(word,0)+1

print(die)

newlst=[(v,k)fork,vindie.items()]

newlst.sort()

print(newlst[-1：-6：-l])

模拟评委打分

在体育赛事中，通常采用多个评委打分然后去

掉一个最高分和一一个最低分取具东卖平3的方法作为最终成绩，请编程模以8

位Z2的过程,即输入8个成绩,然百计兽最冬交并输出，结果保留1位小数

例如输入

8.58.88.78.88.68.48.98.8

输出

8.7

foriinrange(1,9):

x=eval(input())

ifi==1:

sum=max=min=x;

else:

sum+=x

ifx>max:

max=x

ifx<min:

min二x

print(〃{:・If}〃・format((sum-max-min)/6))

输入一串字符作为密码，密码只能由数字与字母组成。

编写一个函数judge(password),用来求出密码的强度level,并在主程序中测

试该函数，根据用户输入的密码，输出对应密码强度。

密码强度判断准则如下(满足其中一条，密码强度增加一级)：

1.有数字;2.有大写字母;3.有小写字母;4.位数不少于8位。

例如用户输入Abcl23则输出3

defjudge(password):

level=0

n=len(passwo