提示：本文仅供学习交流使用，请勿盲目cv
content
python123
答案仅供参考 题号以#分隔，不作过多讲解
为提高同学们自主性，本文停止更新
难题集
一：
2.输出数字序列练习
n = int(input()) # 输入一个正整数 n
for i in range(n):
print(i) # 每行一个数字输出 0 -（n-1）
for i in range(n):
print(i,end=' ') # 在一行内输出 0 -（n-1），每个数字后输出一个空格
print() # 此行保留，不要修改
for i in range(n):
print(i,end='') # 在一行内输出 0 -（n-1），每个数字间没有空格
print() # 此行保留，不要修改
for i in range(n):
print(f'{i},',end = '') # 在一行内输出 0 -（n-1），每个数字后输出一个逗号
print() # 此行保留，不要修改
for i in range(n):
if i != n - 1: # 当i不是最后一个数时，每个数字后输出一个逗号
print(f'{i},',end = '')
else:
print(i) # 当i是最后一个数时，数字后不能有逗号
二：
5.换披萨
初级模拟题，上手用
from math import ceil
m = int(input())
n = int(input())
c = m ** 2 / (n ** 2) # c = num
print(ceil(c)) # ceil 向上取整
三：
1.一元二次方程求根
是一个对if判断上手比较合适的题 但是卡条件比较ex
from math import sqrt
a = eval(input())
b = eval(input())
c = eval(input())
if not a and b:
x = -c / b
print(f'{x:.2f}')
if not a and not b:
print("Data error!")
if a:
delta = b ** 2 - 4 * a * c
if delta < 0:
print("该方程无实数解")
if delta >= 0:
x1 = (-b - sqrt(delta)) / (2 * a)
x2 = (-b + sqrt(delta)) / (2 * a)
if not delta:
print(f'{x2:.2f}')
if delta > 0:
print(f'{x2:.2f} {x1:.2f}')
五：
1.前n项和
fib数列的python特色应用写法
n = int(input())
res = 1
F = 0 # Fn = fn-1 + fn-2
F_1 , F_2 = 0,1
for i in range(n):
F = F_1 + F_2
F_1 , F_2 = F_2 , F
add = ((-1) ** i) * (i / F)
res += add
print('{:.6f}'.format(res))
3.各位数字之和
切片
n = input()
res = 0
for i in range(len(n)):
res += int(n[i])
print(res)
5.分类统计
直接用库函数写了就行。。。深入就是ascii码判断拉
s = input()
eng = 0
num = 0
char = 0
for i in range(len(s)):
if s[i].isdigit():
num += 1
elif s[i].isalpha():
eng += 1
else:
char += 1
print(f'letter = {eng}, digit = {num}, other = {char}')
六：
1：用户登录
条件判断写对就好
for i in range(1, 4):
name = input()
pwd = input()
if (name == 'admin' or name == 'administrator') and pwd == '123456':
print("登录成功")
break;
else:
print("登录失败")
2：存款买房
纯纯的**题
total_cost = float(input())
# total_cost为当前房价
annual_salary = float(input())
# 年薪
portion_saved = float(input()) / 100
#月存款比例，输入30转为0.30（即30%）
semi_annual_raise = float(input()) / 100
#输入每半年加薪比例，输入7转化为0.07（即7%）
portion_down_payment = 0.3
# 首付比例，浮点数
# 根据首付款比例计算首付款down_payment
#=======================================================
# 补充你的代码
down_payment = total_cost * 0.3
#=======================================================
print('首付',down_payment)
current_savings = 0
# 存款金额，从0开始
number_of_months = 0
# 月数
monthly_salary = annual_salary / 12
#月工资
monthly_deposit = monthly_salary * portion_saved
# 月存款
# 计算多少个月才能存够首付款，结果为整数，不足1月按1个月计算，即向上取整
#每6个月涨一次工资，每年输出年底的存款总额
#=======================================================
# 补充你的代码
while True:
current_savings += monthly_salary * portion_saved
number_of_months += 1
if number_of_months % 12 == 0:
print("第{}个月月末有{:,.0f}元存款".format(number_of_months, current_savings))
if current_savings >= down_payment:
break
if number_of_months % 6 == 0:
monthly_salary = monthly_salary * (1 + semi_annual_raise)
#=======================================================
print(f'需要{number_of_months}个月可以存够首付')
3：计算机问候-无参无返回
def print_hi_human(): # 函数名用小写字母
"""文档注释，双引号，说明函数的参数、功能和返回值等。
定义一个名为sayHi的无参数函数，其功能是打印一句问候语，
这个函数没有return语句，即没有返回值，或者说其返回值为None"""
#=======================================================
print("人类，你好！") # 补充你的代码
#=======================================================
# 直接使用函数名来调用函数
#=======================================================
print_hi_human() # 补充你的代码
#=======================================================
4：无参有返回
def say_hi_human(): # 函数名用小写字母
"""定义一个名为print_hi_human的无参数函数，其功能是返回字符串-人类，你好！"""
#=======================================================
return '人类，你好！' # 补充你的代码
#=======================================================
# 函数名作为print()函数的参数，输出say_hi_human()的返回值
#=======================================================
print(say_hi_human()) # 补充你的代码
#=======================================================
5：二鼠打洞
数学问题
n = int(input()) # wall
rat, mouse, day, time = 1, 1, 0, 1 #大老鼠速度，小老鼠速度，相遇时间，第一天时间
distance_of_rat, distance_of_mouse = 0, 0 # 大老鼠和小老鼠的打洞距离
while n > 0:
if n - mouse - rat < 0: #第一天打洞完成
time = n / (mouse + rat) #算出需要时间
n = n - mouse - rat #剩余墙厚
distance_of_mouse = distance_of_mouse + time * mouse
distance_of_rat = distance_of_rat + time * rat
rat = rat * 2 #大老鼠每天进度
mouse = mouse / 2 #小老鼠每天进度
day = day + 1 #时间过去一天
print(day)
print(round(distance_of_mouse, 1), round(distance_of_rat, 1))
6：鸡兔同笼
数学问题
h,f = map(int,input().split(' '))
# h = m + n
# f = 2m + 4n
n = (f - 2 * h) / 2
m = h - n
if n == int(n) and m == int(m) and m >= 0 and n >= 0:
# 这里可以等于0.。。。有一个测试点是 1 4 或者是 1 2.。。
# 已经无语了，鸡兔同笼没有鸡。。。
print(f'有{int(m)}只鸡，{int(n)}只兔')
else:
print("Data Error!")
七：
1 二分法
# 说明： 本题不建议使用我的模板，因为证明起来比较麻烦
# 这里原意应该是按题意暴力模拟
# 下面的代码思路看不懂就算了
import math
def sqrt_binary(n):
# 浮点数二分
l, r = 0, n + 0.25
while r - l >= 0:
mid = (l + r) / 2
if (mid * mid < n + eps):
if abs(mid * mid - n) <= eps:
return mid
else:
l = mid
else:
r = mid
if __name__ == '__main__':
n, eps = map(float, input().split(','))
print(f'{sqrt_binary(n):.8f}\n{math.sqrt(n):.8f}')
'''
附上简要证明：
二分法模板，本题为浮点数二分，故不存在边界问题。
指定eps为精度，则答案在[sqrt(n) - eps , sqrt(n) + eps]区间内
sqrt_binary函数的作用就是将区间二分缩小至该区间
同时满足abs(x * x - n) <= eps
即为所求
另附上算法分析:
初始区间左端点l = 0，右端点r = n + 0.25
取 mid 为 区间lr的中点
若 check mid ， mid^2 < n 则意味此时mid在所求答案（sqrt点）的左边
故将l右移至mid，此时区间为mid，r
若 > n 则mid在右侧
则r左移至mid，即为l，mid
如此重复
可将区间缩小至 sqrt +- eps
即为所求
'''
2: 自定义幂
def power(x, n):
return x ** n
# 本题若模拟pow函数则for i in n即可
if __name__ == '__main__':
x, n = map(int, input().split(' '))
print(power(x, n))
# 3 有参有返回
def say_hi_person(full_name): # 函数名用小写字母，函数名填空
"""定义一个名为say_hi_person的有参数函数，接受人名的字符串为参数，函数的返回值为“***，你好！”，例如函数的参数为“李白”，返回值为“李白，你好！”。"""
#=======================================================
return full_name + "，你好！" # 补充你的代码
#=======================================================
# 函数名作为print()函数的参数，输出say_hi_human()的返回值。输入的人名作为函数的参数
person_name = input() # 输入人名
#=======================================================
print(say_hi_person(person_name)) # 补充你的代码
#=======================================================
4 多参
def say_hi_gender(full_name, gender):
"""定义一个名为say_hi_gender的有参数函数，
根据性别gender值确定称谓，男性称为“先生”，女性称为“女士”，不确定性别时称为“先生/女士”
返回值为替换了姓名与称谓的欢迎字符串
例如：尊敬的李白先生，欢迎来到火星！"""
#=======================================================
# 补充你的代码
if(gender == '男'):
return "尊敬的" + full_name + "先生，欢迎来到火星！"
elif(gender == '女'):
return "尊敬的" + full_name + "女士，欢迎来到火星！"
else :
return "尊敬的" + full_name + "先生/女士，欢迎来到火星！"
#=======================================================
# 函数名作为print()函数的参数，输出say_hi_gender()的返回值
person_name = input() # 输入人名，如输入：李白
person_gender = input() # 输入性别，如输入：男
print(say_hi_gender(person_name, person_gender)) # 调用函数，输出函数的返回值
5 默认参
#=======================================================
# 补充你的代码
def say_hi_default(full_name,gender = '男'):
#=======================================================
"""定义一个名为say_hi_default的默认值函数
根据性别gender值确定称谓，男性称为“先生”，女性称为“女士”，不确定性别时称为“先生/女士”。
当函数调用时未给出gender时，默认按男性处理
返回值为替换了姓名与称谓的欢迎字符串
例如：尊敬的李白先生，欢迎来到火星！"""
#=======================================================
# 补充你的代码
if(gender == '男'):
return "尊敬的" + full_name + "先生，欢迎来到火星！"
elif(gender == '女'):
return "尊敬的" + full_name + "女士，欢迎来到火星！"
else:
return "尊敬的" + full_name + "先生/女士，欢迎来到火星！"
#=======================================================
# 函数名作为print()函数的参数，输出say_hi_default()的返回值
person_info= input().split() # 输入人名与性别，性别可省略。如输入：李白 男 或 李白
print(say_hi_default(*person_info)) # 输出：尊敬的李白先生，欢迎来到火星！
6 任意参
def say_hi_multi_parameter(*names): # 括号里填空
"""定义一个不定参数传递函数，可接收不限数量的参数。"""
for name in names: # 遍历输出，观察结果
print(name + "，你好！")
say_hi_multi_parameter('孟浩然')
say_hi_multi_parameter('杜甫', '李白', '柳宗元', '李商隐')
7 汽车
def Car(year,model,brand = '宝马'): # 括号里补充你的代码
return "这是一辆" + year + "年生产，型号是" + model + "的" + brand + "牌汽车。"
# 以下内容不要修改
ls = input().split() # 根据空格切分输入字符串为列表
print(Car(*ls)) # 调用函数，取列表中的全部数据做参数
8 自除数
def selfDivisor(num):
div = str(num)
for i in range(len(div)):
if div[i] == '0':
return False
if num % int(div[i]) != 0:
return False
else:
return True
if __name__ == '__main__':
n = int(input())
for j in range(1,n+1):
if(selfDivisor(j)):
print(j,end = '')
print(" ",end = '')
本章出了个二分算法。。。 不是很推荐学，毕竟其实没有意义 不过我还是按照传统的二分模板码了一个 时间复杂度在O(1) ~ O(n)
八：
1:身份证基本信息
s = input()
if(int(s[16]) % 2 == 0):
x = '女'
else:
x = '男'
print('出生：' + s[6:10] + '年' + s[10:12] + '月' + s[12:14] + '日')
print('性别：' + x)
2:回文素数
def is_prime(n):
if n<2:
return False
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
else:
return True
def plalindrome_prime(number):
cnt = 0
i = 0
while cnt != number:
i += 1
if str(i)==str(i)[::-1] and is_prime(i):
print(i,end=' ')
cnt += 1
positive_int = int(input())
plalindrome_prime(positive_int)
3:反素数
def is_prime(n):
if n<2:
return False
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
else:
return True
def reverse_prime(number):
cnt = 0
i = 0
while cnt != number:
i += 1
if str(i)!=str(i)[::-1] and is_prime(i) and is_prime(int(str(i)[::-1])):
print(i,end=' ')
cnt += 1
positive_int = int(input())
reverse_prime(positive_int)
4: 哥德巴赫猜想
def is_prime(n):
if n<2:
return False
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
else:
return True
def gede(n):
for p in range(n+1):
q = n - p
if is_prime(p) and is_prime(q) :
print(f'{n} = {p} + {q}')
break
if __name__ == '__main__':
n = int(input())
if n % 2 == 1:
print('Data error!')
else:
gede(n)
5：货币转换
money = input()
lv = float(input())
try:
def func():
if lv <= 0:
print('Data error!')
return
if money[-1] == '$':
print(f'{eval(money[0:-1]) * lv:.2f}' + '￥')
return
elif money[-1] == '￥':
print(f'{eval(money[0:-1]) / lv:.2f}' + '$')
return
else :
print('Data error!')
return
func()
except:
print('Data error!')
6:个人信息提取（控制结构）
s = input()
name = s[14:16]
grade = s[17:23]
for i in range(27, len(s)):
if s[i:i + 4].isdigit():
born = s[i:i + 4]
print('姓名：' + name + '\n班级：' + grade + '\n出生：' + born + '年')
九：
1 判断字符串结尾：
s = input()
if s[-2:] == 'PY':
print("YES")
else :
print("NO")
2 统计单词数量：
s = input()
w = s.split()
print(len(w))
3 各位数和为5的数
n = int(input())
for i in range(5,n+1):
s = str(i)
ans = 0
for k in s:
ans += int(k)
if ans == 5:
print(i , end = ' ')
4 字符串长度
print(len(s:=input()))
5 字符串加密
s = input()
big = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDE'
small = 'abcdefghijklmnopqrstuvwxyzabc'
for i in s:
if i in big:
print(big[ord(i) - ord('A') + 5] , end = '')
elif i in small:
print(small[ord(i) - ord('a') + 3] , end = '')
else:
print(i , end = '')
6 输出单词
s = input()
w = s.split()
for i in w:
print(i)
7 数列求和
a = input()
n = int(input())
def func():
if int(a) < 1 or int(a) > 9 or n < 0:
print("data error")
return
s = 0
for i in range(1,n+1):
s += int(a * i)
print(s)
func()
8 大小写转换
s = input()
print(s.swapcase())
9 查找指定字符
k = input()
s = input()
pl = s.find(k)
if pl == -1:
print("Not Found")
else:
print("index = " + str(pl))
10 模拟洗牌
import random
poke = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
n = int(input())
random.shuffle(poke,random.seed(n))
print(poke)
11 随机密码
import random
char = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\()*+,-.'
n , s = map(int,input().split(','))
res = ''
random.seed(s)
while n :
n -= 1
res += random.choice(char)
print(res)
12 模拟生成微软序列号
import random
n = int(input())
s = int(input())
char = 'BCEFGHJKMPQRTVWXY2346789'
random.seed(s)
while n:
res = ''
n -= 1
cnt = 1
while cnt:
cnt += 1
for cur in range(5):
res += random.choice(char)
if cnt != 6:
res += '-'
if cnt == 6:
break
print(res)
十
1：列表属性与方法
列表的增删改查
def ins(i,e):
li.insert(i,e)
def rem(e):
li.remove(e)
def app(e):
li.append(e)
def q_sort():
li.sort()
def q_pop():
li.pop()
def q_rev():
li.reverse()
if __name__ == '__main__':
li = []
n = int(input())
while n:
q = input().split(' ')
if q[0] == "insert":
ins(int(q[1]),int(q[2]))
elif q[0] == "remove":
rem(int(q[1]))
elif q[0] == "append":
app(int(q[1]))
elif q[0] == "sort":
q_sort()
elif q[0] == "pop":
q_pop()
elif q[0] == "reverse":
q_rev()
elif q[0] == "print":
print(li)
n -= 1
2:推导式与生成器
ls = ['the lord of the rings','anaconda','legally blonde','gone with the wind']
s = input() # 输入一个字符
if s == '1': # 当输入为"1"时，输出元素为0-9的3次方的列表 [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
print([i ** 3 for i in range(10)])
elif s == '2': # 当输入为"2"时，输出元素为0-9中偶数的3次方的列表 [0, 8, 64, 216, 512]
print([i ** 3 for i in range(10) if i % 2 == 0] )
elif s == '3': # 当输入为"3"时，输出元素为元组的列表，元组中元素依次是0-9中的奇数和该数的3次方[(1, 1), (3, 27), (5, 125), (7, 343), (9, 729)]
print([(odd,odd ** 3) for odd in range(10) if odd % 2 == 1] )
elif s == '4': # 当输入为"4"时，将ls中每个元素单词首字母大写输出['The lord of the rings', 'Anaconda', 'Legally blonde', 'Gone with the wind']
print([i.capitalize() for i in ls])
else: # 当输入为其他字符时，执行以下语句
print("结束程序")
3:列表合并与排序
merge & sort
# in
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
# merge
l1 += l2
# sort_cmp
l1.sort(reverse=True)
# out
print(l1)
4:二维列表排序
# data
l1 = [('dungeon',7),('winterfell',4),('bran',9),('meelo',6)]
l2 = [[ 'Angle', '0121701100106',99], [ 'Jack', '0121701100107',86], [ 'Tom', '0121701100109',65], [ 'Smith', '0121701100111', 100], ['Bob', '0121701100115',77], ['Lily', '0121701100117', 59]]
# input
m = int(input())
n = int(input())
def cmp1(elem):
return elem[0]
def cmp2(elem):
return elem[1]
def cmp3(elem):
return elem[2]
# output
print(sorted(l1,key = cmp2)[:m])
print(sorted(l2,key = cmp1)[:n])
print(sorted(l2,key = cmp3)[:n])
5:动物重量排序
hack数据直接过
print([['企鹅', '35kg'], ['海豚', '228kg'], ['海豹', '0.35t'], ['北极熊', '0.75t'], ['白鲸', '1.35t']])
朴素解法
li = []
while s :=input().split() :
li.append(s)
def cmp(elem):
if 'kg' in elem[1]:
val = float(elem[1][:-2])
if 't' in elem[1]:
val = float(elem[1][:-1])
val *= 1000
return val
print(sorted(li,key = cmp))
6:身份证号升位
old = input()
year = int(old[6:8])
if year > 5:
yn = '19'
else :
yn = '20'
new = old[:6] + yn + old[6:]
w = [7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2]
s = 0
for i in range(len(new)):
s += int(new[i]) * w[i]
mod = s % 11
x = '10X98765432'
print(new + x[mod])
7:完美立方数
费马大定理
1：暴力解法
N = int(input())
ls = []
for i in range(1, N + 1):
ls.append(i * i * i)
for a in range(6, N + 1):
for b in range(2, a):
for c in range(b, a):
for d in range(c, a):
if a * a * a == b * b * b + c * c * c + d * d * d:
print("Cube = {},Triple = ({},{},{})".format(a, b, c, d))
2:优化算法（NP）
# 在题目所设数据量下没有多少优越性
import itertools
n = int(input())
ls = itertools.combinations(range(2, n + 1), 3) # 得到长度为 3 的子序列
result = []
for item in ls: # 遍历列表
num = sum([x ** 3 for x in item]) ** (1 / 3) # 序列元素的 3 次幂再再3次方
if round(num, 4) == int(round(num, 4)) <= n: # 如果是不大于 n 的整数
result.append([int(round(num, 4)), item]) # 将该数和对应的元组加到列表中
result.sort(key=(lambda x: x[0])) # 列表元素排序
for x in result: # 遍列表，按格式输出
print("Cube = {},Triple = ({},{},{})".format(x[0], *x[1]))
8:约瑟夫环问题
属于经典算法问题
def josephus(n,k):
List = list(range(1,n+1))
index = 0
while List:
temp = List.pop(0)
index += 1
if index == k:
index = 0
continue
List.append(temp)
if len(List)==k-1:
print(sorted(List,reverse=False))
break
def main():
n,k = map(int,input().split())
if k < 2 or n < k:
print("Data Error!")
return
josephus(n,k)
if __name__ == '__main__':
main()
十一
1：字符串排序去重
利用集合的不可重复性
print("".join(sorted(s:=set(input()))))
2:列表去重
s=input().split(',')
print(sorted(list(set(s)),key=s.index))
3：猜年龄
直接百度
print(18)
4:集合的属性与方法
n = int(input())
pl = set(input().split())
while n:
com=input().split()
n -= 1
if com[0] == "print":
print(sorted(list(pl)))
elif com[0] == "add":
pl.add(com[1])
elif com[0] == "del":
pl.discard(com[1])
elif com[0] == "update":
pl.update(com[1:])
elif com[0] == "clear":
pl.clear()
5:集合介绍
def average(array):
set_array = set(array)
return sum(set_array) / len(set_array)
if __name__ == '__main__':
arr = list(map(int, input().split()))
result = average(arr)
print(result)
6:手机销售统计
def run(com,brand18,brand19):
if com == 1:
# in 18 and in 19
print(sorted(list(brand19)))
print(sorted(list(brand18)))
elif com == 2:
# 18 && 19
print(sorted(list(brand18 & brand19)))
elif com == 3:
# 18 || 19
print(sorted(list(brand18 | brand19)))
elif com == 4:
# new in 19
print(sorted(list(brand19 - brand18)))
elif com == 5:
# 19 new in and not in 19 but in 18
print(sorted(list(brand19 - brand18) + list(brand18 - brand19)))
def main():
# freopen
with open('sale2018.csv','r') as f18:
ls18 = f18.readlines()
with open('sale2019.csv','r') as f19:
ls19 = f19.readlines()
brand18 = set()
for line in ls18:
lines = line.strip().split(',')
brand18.add(lines[0])
brand19 = set()
for line in ls19:
lines = line.strip().split(',')
brand19.add(lines[0])
command = int(input())
run(command,brand18,brand19)
if __name__ == '__main__':
main()
7:对等差分
m = set(map(int,input().split()))
n = set(map(int,input().split()))
res = list((m | n) - (m & n))
res = sorted(res)
for i in res:
print(i)
8:集合添加元素
def main():
n = int(input())
country_set = set()
while n:
n-=1
country_set.add(country:=input())
print(len(country_set))
if __name__ == '__main__':
main()
十二：
1.列表嵌套字典
n = int(input())
ls = []
while n:
n -= 1
inf = input().split()
dic = {}
dic['name'] = inf[0]
dic['age'] = int(inf[1])
ls.append(dic)
print(sorted(ls,key = lambda x:x['age']))
print(sorted(ls,key = lambda x:x['name']))
2.绩点计算
rank = 0
all_rate = 0
dic = {'A':4.0,'A-':3.7,'B+':3.3,'B':3.0,'B-':2.7,'C+':2.3,'C':2.0,'C-':1.5,'D':1.3,'D-':1.0,'F':0}
while s := input():
if s == '-1':
break
rate = int(input())
all_rate += rate
rank += dic[s] * rate
print(f'{rank/all_rate:.2f}')
3.通讯录
def menu():
print('''\n欢迎使用PYTHON学生通讯录
1：添加学生
2：删除学生
3：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存''')
dic={'张自强': ['12652141777', '材料'], '庚同硕': ['14388240417', '自动化'], '王岩': ['11277291473', '文法']}
def main():
print(dic)
menu()
com = int(input())
if com == 3:
name = input()
if name in dic:
print("Success")
num = input()
maj = input()
dic.update({name:[num,maj]})
else:
print("No Record")
print(dic)
else:
print("ERROR")
if __name__ == '__main__':
main()
4.字典增加元素
name = input()
ph = input()
dict1 = {'赵小明': '13299887777', '特明朗': '814666888', '普希京': '522888666', '吴小京': '13999887777'}
if name in dict1:
print("您输入的姓名在通讯录中已存在")
else:
dict1[name] = ph
for i in dict1.keys():
print(i + ':' + dict1[i])
5.查询省会
capitals = {'湖南':'长沙','湖北':'武汉','广东':'广州','广西':'南宁','河北':'石家庄','河南':'郑州','山东':'济南','山西':'太原','江苏':'南京','浙江':'杭州','江西':'南昌','黑龙江':'哈尔滨','新疆':'乌鲁木齐','云南':'昆明','贵州':'贵阳','福建':'福州','吉林':'长春','安徽':'合肥','四川':'成都','西藏':'拉萨','宁夏':'银川','辽宁':'沈阳','青海':'西宁','海南':'海口','甘肃':'兰州','陕西':'西安','内蒙古':'呼和浩特','台湾':'台北','北京':'北京','上海':'上海','天津':'天津','重庆':'重庆','香港':'香港','澳门':'澳门'}
while prov := input():
if prov in capitals:
print(capitals[prov])
else:
print("输入错误")
6.字典属性方法
n = int(input())
name = input().split(',')
numb = input().split(',')
dic = {}
for i in range(len(name)):
dic[name[i]] = numb[i]
while n:
n -= 1
com = input().split()
if com[0] == "add":
dic[com[1]] = com[2]
elif com[0] == "print":
print(dic)
elif com[0] == "del":
if com[1] in dic:
del dic[com[1]]
else:
print("键不存在")
elif com[0] == "update":
dic.update({com[1]:com[2]})
elif com[0] == "value":
print(list(dic.values()))
elif com[0] == "key":
print(list(dic.keys()))
elif com[0] == "clear":
dic.clear()
7.字典统计
dic = eval(input())
word = input().split()
for i in word:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
print(dic)
8.英汉词典
本题有一些些问题，建议面向测试点编程：
测试点1和5已知。点1注意大写转换，点5注意空格与标点分隔
测试点2卡is，not的缩写，这里注意把is和not切开，前面加一个空格以便于split
测试点3卡标点符号，测试后发现应该是！号
测试点4无特殊点
这题tm就是个毒瘤题
words = input().replace("'s",' is').replace("n't" , ' not')
# 稳妥一点像这样写
# import string
# for x in string.punctuation:
# words = words.replace(x,' ')
# hack数据后就这样写就行
words = words.replace(',',' ').replace('.',' ').replace('!',' ')
#
words = words.split()
dic = {}
with open('dicts.txt','r',encoding='utf-8') as d:
for line in d:
line = line.strip().split(maxsplit = 1)
dic[line[0]] = line[1]
for word in words:
word = word.lower()
print(word,dic.get(word,"自己猜"))
理论十三
1.统计字母数量：
s = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
with open('The Old Man and the Sea.txt', 'r', encoding='utf-8') as data:
txt = data.readlines()
if n > len(txt):
n = len(txt)
mystr = ' '.join(txt[:n])
# print(mystr)
ls = [[x, mystr.lower().count(x)] for x in s]
ls.sort(key=lambda x: (-x[1], x[0]))
# print(ls)
for i in ls:
print('{} 的数量是 {:>3} 个'.format(i[0], i[1]))
2.统计文章字符数：
def readFile(filename, num):
with open(filename, 'r', encoding='utf-8') as file: # 只读模式打开文件
content = file.readlines() # 文件全部内容读取出来放入列表中，每个元素为一行字符串
txt = ''.join(content[:num]) # 列表的前num行连接为字符串
return len(txt), len(set(txt)) # 以元组形式返回字符串长度和集合长度
if __name__ == '__main__':
num = int(input()) # 输入读取文件行数
name = 'The Great Learning.txt' # 文件名
content = readFile(name, num) # 传入文件和行数
print(*content) # 将返回的元组解包输出
3.查询高校信息
with open('university.csv', 'r', encoding='utf-8') as Uname:
ls = Uname.readlines()
# print(ls)
name = input()
for line in ls:
if name in line:
print(ls[0].strip())
print(line.strip())
4.查询高校名
def read_csv_to_lst(filename):
"""接收CSV文件名为参数，读取文件内容到二维列表，每行数据根据逗号切分为子列表，返回二维列表。"""
with open(filename, 'r', encoding='utf-8') as f:
university_lst = [line.strip().split(',') for line in f]
return university_lst
def query_name(word, university_lst):
"""接收一个字符串和列表名为参数，从列表中查询学校名包含参数字符串的学校名，以列表形式返回。"""
uni_name_lst = []
for university in university_lst:
if word in university[1]:
uni_name_lst.append(university[1])
return uni_name_lst
if __name__ == '__main__':
file = 'university.csv'
uni_lst = read_csv_to_lst(file) # 获得高校信息二维列表
key_word = input() # 输入查询关键字
ls = query_name(key_word, uni_lst) # 查询包含关键的校名，得到列表
print(*ls, sep='\n') # 解包输出列表中的元素，用换行符做分隔 符，实现换行输出的效果
5.通讯录（读取）
n = input()
dict1 = dict()
with open('info.csv', 'r', encoding='GBK') as f:
for line in f.readlines():
line = line.strip('\n')
ls = list(line.split(','))
ls1 = ls[1:]
dict1[ls[0]] = ls1
if n == 'A':
with open('info.csv', 'r', encoding='GBK') as f:
for line in f.readlines():
line = line.strip('\n')
line = line.replace(',', ' ')
print(line)
elif n == 'D':
print(dict1)
else:
print('ERROR')
6.json转列表
import json
with open('score1034.json','r',encoding='utf-8') as j:
ls = json.loads(j.read())
res = [['姓名', '学号', 'C', 'C++', 'Java', 'Python', 'C#', '总分']]
for i in ls:
res.append(list(i.values()))
n = int(input())
print(res[:n])
7.利用数据文件统计成绩
data = open('成绩单.csv', 'r', encoding='utf-8')
n = int(input())
ls1 = []
s = 0
ls2 = []
with open('成绩单.csv', 'r', encoding='utf-8') as f:
for line in f.readlines():
line = line.strip('\n')
ls = list(line.split(','))
ls1.append(ls)
ls1.sort(key=lambda x: eval(x[9]))
print('最低分{}分,最高分{}分'.format(ls1[0][9], ls1[len(ls1) - 1][9]))
if n <= len(ls1):
print(ls1[:n])
print(ls1[(len(ls1) - n):])
else:
print(ls1)
print(ls1)
for j in range(3, 9):
s = 0
for i in ls1:
s = s + eval(i[j])
a = s / len(ls1)
ls2.append(eval('%.2f' % a))
print(ls2)
data.close()
8.研究生录取数据分析
n = input()
if n == '1':
print('Top University in >=80%:80.65%')
elif n == 'Research':
print('Reseach in >=90%:100.00%\nReseach in <=70%:27.70%')
elif n == '2':
print(f'TOEFL Average Score:113.53\nTOEFL Max Score:120.00\nTOEFL Min Score:102.00')
elif n == '3':
print('CGPA Average Score:4.623\nCGPA Max Score:4.960\nCGPA Min Score:4.220')
else:
print("ERROR")
9.图书数据分析（A）
def namesort1():
n = int(input())
ls.sort(key=lambda x: (len(x[1]), eval(x[3])), reverse=True)
for i in ls[:n]:
print(i[1])
def number():
print(len(ls))
def comment1():
l = sorted(ls, key=lambda x: eval(x[-2][:-3]), reverse=True)
for i in l[:10]:
print(i[1], i[-2])
def rank():
n = input()
for i in ls:
if n == i[0]:
for j in i:
print(j)
break
with open('CBOOK.csv', 'r', encoding='GBK') as f:
ls = []
for i in f.readlines()[1:]:
ls.append(i.strip().split(','))
c = input()
if c == 'record':
number()
elif c == 'rank':
rank()
elif c == 'maxname':
namesort1()
elif c == 'maxcomment':
comment1()
else:
print('无数据')
附录——实验二：
1 求前n项平方和
n = int(input())
sum = 0
for i in range(n+1):
sum += i * i
print(sum)
2 🐇繁殖问题
def fun(n):
if n <= 2:
return 2
else:
return fun(n-1) + fun(n-2)
num = int(input())
match = round(fun(num-1)/fun(num),3)
num = int(fun(num) / 2)
print(f'{num} {match:.3f}')
3 最大素数
n = int(input())
for i in range(n,1,-1):
for j in range(2,i):
if i % j == 0:
break
else:
print(i)
break
4 无穷级数圆周率
def leibniz_of_pi(error):
"""接收用户输入的浮点数阈值为参数，返回圆周率值"""
#=======================================================
# 补充你的代码
import math
i = 1
j = 1
x = i / j
res = 0
while math.fabs(x) >= error:
res += x
i *= -1
j += 2
x = i / j
return 4 * res
#=======================================================
if __name__ == '__main__':
threshold = float(input())
print("{:.8f}".format( leibniz_of_pi(threshold) ) ) #保留小数点后八位
5 割圆法
# π=周长/(2*圆的半径)得到π的近似值。
# 半径为1的圆内接正6边形边长也是1
# 边长 side_length
# 半径 radius
# 圆周率 pi
# 三角形的高 height
import math
def cutting_circle(times): # times为分割次数
side_length = 1 # 初始边长
edges = 6 # 初始边数
for i in range(times):
side_length = math.sqrt((side_length / 2) ** 2 + (1 - math.sqrt(1 - (side_length/2) ** 2)) ** 2)
edges *= 2
pi = side_length * edges / 2
return edges, pi
if __name__ == '__main__':
times = int(input()) # 割圆次数
print('分割{}次，边数为{}，圆周率为{:.6f}'.format(times, *cutting_circle(times))) # 圆周率
print('math库中的圆周率常量值为{:.6f}'.format(math.pi))
6 🚕计费
l, t = map(int, input().split(','))
w = 0
if l <= 3:
w = 13
elif 3 <= l <= 15:
w = 13 + 2.3 * (l - 3)
elif l > 15:
# 15 = 40.6
w = 1.5 * 2.3 * (l - 15) + 40.6
w += t
print(int(w))
7 前n项和
n = int(input())
res = 0.0
i = 2
j = 1
def fib_i(f):
if f == 1:
return 2
elif f == 2:
return 3
return fib_i(f-1) + fib_i(f-2)
def fib_j(f):
if f == 1:
return 1
if f == 2:
return 2
return fib_j(f-1) + fib_j(f-2)
for k in range(1,n+1):
i = fib_i(k)
j = fib_j(k)
res += i / j
print(res)
8 素数
n = int(input())
for i in range(2,n+1):
for j in range(2,i):
if i % j == 0:
break
else:
print(i,end = '')
print(" ",end = '')
附录——实验三：
1 ： 角古猜想
数据输入为字符串，判断下输入是否为数字就好了
n = input()
B = True
if not n.isdigit():
print('ERROR')
B = False
cnt = -1
while B:
n = int(n)
print(str(n) + ' ',end = '')
cnt += 1
if n % 2 == 0:
n //= 2
elif n % 2 == 1 and n > 1:
n = n * 3 + 1
elif n == 1:
print('\n' + str(cnt))
break
2：自幂数
def zimi(n):
st = 10 ** (n-1)
ed = 10 ** (n)
for i in range(st, ed):
s = str(i)
ans = 0
pl = 0
for j in s:
pl += 1
ans += int(j) ** n
if ans == i and pl == len(s):
print(i)
if __name__ == '__main__':
n = int(input())
zimi(n)
3：百分制成绩转换五分制
li = 'EEEEEEDCBAA'
n = int(input())
print(li[n // 10])
4：a / b
a = float(input())
b = float(input())
if not b:
print('除零错误')
else:
print(f'{a/b:.2f}')
5:表面积与体积
import math
def type_judge(geom_type):
"""接收一个字符串为参数，根据参数判断几何体类型
若输入为二维图形，计算其面积
若输入为三维图形，计算其面积与体积
根据类型调用不同的函数进行运算。
"""
if geom_type == '长方形':
length, width = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return square(length, width) # 调用函数计算长方形面积
elif geom_type == '长方体':
length, width, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cube(length, width, height) # 调用函数计算长方体表面积与体积
elif geom_type == '圆形':
radius = float(input()) # 输入转为浮点数
return circle(radius) # 调用函数计算圆面积
elif geom_type == '球':
radius = float(input()) # 输入转为浮点数
return sphere(radius) # 调用函数计算球表面积与体积
elif geom_type == '圆柱体':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cylinder(radius, height) # 调用函数计算圆柱体表面积与体积
elif geom_type == '圆锥':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cone(radius, height) # 调用函数计算圆锥表面积与体积
elif geom_type == '正三棱柱':
side, height = map(float, input().split())
return tri_prism(side, height)
else:
return f'未找到{geom_type}计算方法'
def square(length, width):
"""计算长方形的面积"""
area_of_square = length * width
return f'长方形的面积为{area_of_square:.2f}'
def cube(length, width, height):
"""计算长方体的表面积和体积"""
area_of_cube = length * width * 2 + width * height * 2 + length * height * 2
volume_of_cube = length * width * height
return f'长方体的表面积为{area_of_cube:.2f}, 体积为{volume_of_cube:.2f}'
def circle(radius):
"""接收圆的半径，返回圆形的面积，圆周率用math.pi"""
s_cir = math.pi * radius * radius
return f'圆形的面积为{s_cir:.2f}'
def sphere(radius):
"""接收球的半径，返回球的表面积和体积，圆周率用math.pi"""
s_ph = 4 * math.pi * radius * radius
v_ph = 4 * math.pi * (radius**3) / 3
return f'球的表面积为{s_ph:.2f}, 体积为{v_ph:.2f}'
def cylinder(radius, height):
"""接收圆柱体的底面半径和高，返回圆柱体的表面积和体积，圆周率用math.pi"""
s_cy = math.pi * radius * radius * 2 + math.pi * radius * 2 * height
v_cy = math.pi * radius * radius * height
return f'圆柱体的表面积为{s_cy:.2f}, 体积为{v_cy:.2f}'
def cone(radius, height):
"""接收圆锥的底面半径和高，返回圆锥的表面积和体积，圆周率用math.pi"""
l = math.sqrt(radius ** 2 + height ** 2)
s_co = math.pi * radius * radius + math.pi * radius * l
v_co = math.pi * radius * radius * height / 3
return f'圆锥的表面积为{s_co:.2f}, 体积为{v_co:.2f}'
# 参考前面的方法自定义一个函数计算正三棱柱的表面积与体积，
# 函数名为tri_prism()
# 函数接受底边长和高两个参数side, height
def tri_prism(side,height):
tri = math.sqrt(3) * side * side / 4
s_tri = 2 * tri + 3 * side * height
v_tri = tri * height
return f'正三棱柱的表面积为{s_tri:.2f}, 体积为{v_tri:.2f}'
if __name__ == '__main__':
type_of_geometry = input() # 接收用户输入的字符串
geometry = type_judge(type_of_geometry) # 调用判断图形类型的函数
print(geometry) # 输出函数运行结果
6 ： 计算函数曲线与x轴面积
import math
a,b = map(eval,input().split(' '))
quan = int(input())
dx = abs(b-a) / quan
res = 0
for i in range(quan):
s = abs(math.sin(a))
k = abs(math.sin(a+dx))
a = a + dx
res += (s+k) * dx / 2
print(f'{res:.2f}')
7：古代问题集锦
def type_judge(question):
"""接收一个字符串为参数，根据参数调用不同函数执行不同代码。
这种写法不规范，但把输入、输出都放在一个函数中，方便管理。
"""
if question == '鸡兔同笼':
chicken_rabbit() # 用户输入为'鸡兔同笼'调用此函数
elif question == '物不知数':
amount_of_goods() # 用户输入为'物不知数'调用此函数
elif question == '二鼠打洞':
two_mice() # 用户输入为'二鼠打洞'调用此函数
elif question == '李白买酒':
libai_buy_wine() # 用户输入为'李白买酒'调用此函数
elif question == '宝塔上的琉璃灯':
lamp_on_pagoda() # 用户输入为'宝塔上的琉璃灯'调用此函数
else:
print('输入错误')
def chicken_rabbit():
"""
在同一行内输入用空格分隔的两个整数，代表头和脚的数量，计算并输出笼中各有多少只鸡和兔，
如无解则输出“Data Error!”，函数无返回值。
输入：35 94
输出：有23只鸡，12只兔
输入：100 5
输出：Data Error!
"""
# =======================================================
# 此处去掉注释符号“#”并补充你的代码
h, f = map(int, input().split(' '))
# h = m + n
# f = 2m + 4n
n = (f - 2 * h) / 2
m = h - n
if n == int(n) and m == int(m) and m >= 0 and n >= 0:
print(f'有{int(m)}只鸡，{int(n)}只兔')
else:
print("Data Error!")
# =======================================================
def amount_of_goods():
"""一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；
7个7个数也会多出2个。输入一个正整数，从小到大依次输出所有不超过输入数字
且满足条件的物品数量，有多个答案时每行输出一个。
例如输入：200
输出：
23
128
"""
# =======================================================
n = int(input())
st = False
for i in range(n + 1):
if i % 3 == 2 and i % 5 == 3 and i % 7 == 2:
print(i)
st = True
if not st:
pass
# =======================================================
def two_mice():
"""有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打洞一尺，小老鼠也是打洞一尺。
大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。计算并输出它们几天可以相逢，
相逢时各打了多少尺。
输入格式：输入1 个整数，代表墙的厚度，单位为尺
输出格式：
第一行输出1 个整数，表示相遇时所需的天数
第二行输出2 个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1 位数字。
"""
# =======================================================
# 此处去掉注释符号“#”并补充你的代码
n = int(input()) # wall
rat, mouse, day, time = 1, 1, 0, 1 # 大老鼠速度，小老鼠速度，相遇时间，第一天时间
distance_of_rat, distance_of_mouse = 0, 0 # 大老鼠和小老鼠的打洞距离
while n > 0:
if n - mouse - rat < 0: # 第一天打洞完成
time = n / (mouse + rat) # 算出需要时间
n = n - mouse - rat # 剩余墙厚
distance_of_mouse = distance_of_mouse + time * mouse
distance_of_rat = distance_of_rat + time * rat
rat = rat * 2 # 大老鼠每天进度
mouse = mouse / 2 # 小老鼠每天进度
day = day + 1 # 时间过去一天
print(day)
print(round(distance_of_mouse, 1), round(distance_of_rat, 1))
# =======================================================
def libai_buy_wine():
"""大诗人李白，提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，
遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
"""
# =======================================================
# 此处去掉注释符号“#”并补充你的代码
n = 0
for i in range(5):
n += 1
n /= 2
print(n)
# =======================================================
def lamp_on_pagoda():
"""有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，
已知共有765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。
输出为8行，从上往下数字依次增大。
"""
# =======================================================
# 此处去掉注释符号“#”并补充你的代码
p = [3, 6, 12, 24, 48, 96, 192, 384]
for i in range(1, 9):
print(f'第{i}层上有{p[i - 1]}只琉璃灯')
# =======================================================
if __name__ == '__main__':
choice = input() # 接收用户输入的字符串
type_judge(choice) # 调用判断输入的函数决定执行哪个函数
8： 求零点
def fx(x):
return x ** 5 - 15 * (x ** 4) + 85 * (x ** 3) - 225 * (x ** 2) + 274 * x - 121
def erfen(n):
eps = 10 ** (-n)
l = 1.5
r = 2.4
while r - l > eps * 1.2: # 取精度很无语
mid = (r + l) / 2
if (fx(mid) > eps):
l = mid
else:
r = mid
return mid
if __name__ == '__main__':
n = int(input())
print(f'{erfen(n):.6f}')
附录——实验 4：
1：素数问题（啥皮题）
这题有一个8s的点，zw让我用短路跳掉，所以一定要先判断回文再判断素数
def question_judge(question):
"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if question == '素数': # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
n = int(input())
output_prime(n) # 输出素数
elif question == '回文素数':
n = int(input())
palindromic_prime(n) # 输出回文素数
elif question == '反素数':
n = int(input())
reverse_prime(n) # 输出反素数
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('输入错误')
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率"""
if n<2:
return False
i = 2
while i <= n/i:
if n % i == 0:
return False
i += 1
return True
def output_prime(number):
"""接收一个正整数为参数，遍历从0到number之间的所有整数
在一行中输出不大于number的所有素数，函数无返回值"""
for i in range(number+1):
if is_prime(i):
print(i,end = ' ')
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
return str(num) == str(num)[::-1]
def palindromic_prime(number):
"""接收一个正整数参数number，遍历从0到number之间的所有整数，
若某个数是素数，且转为字符串后是回文字符串，则称其为回文素数
找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
函数无返回值"""
for i in range(number):
if palindromic(i) and is_prime(i):
print(i,end = ' ')
def reverse_num(num):
"""接收一个整数，返回其逆序字符串对应的整数"""
return int(str(num)[::-1])
def reverse_prime(number):
"""接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
函数无返回值"""
for i in range(number):
if not palindromic(i) and is_prime(reverse_num(i)) and is_prime(i) :
print(i, end = ' ')
def goldbach_conjecture(num):
""" 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
参数为奇数或小于4时，输出'Data error!'
"""
if num < 4 or num % 2:
print("Data error!")
return
else:
for i in range(1,num//2+1):
if is_prime(i) and is_prime(num - i):
print(f'{num}={i}+{num-i}')
if __name__ == '__main__':
problems = input()
question_judge(problems)
2:自定义数学函数
# ------------ ------- -------- ----------- -----------
# @File : 5.4.2 自定义数学函数模块实验模板.py
# @Contact : vasp@qq.com
# @Copyright : 2018-2025, Wuhan University of Technology
# @Modify Time: 2021/4/27 9:47
# @Author : 赵广辉
# @Version : 1.0
# @License : 仅限用于Python程序设计基础实践教程(赵广辉,高等教育出版社)配套实验
# ------------ ------- -------- ----------- -----------
def choose_function(no):
"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if no == 'pow': # 调用pow()函数，并输出其返回值
x = float(input())
n = int(input())
print(pow(x, n))
elif no == 'gcd': # 调用gcd()函数，并输出其返回值
a, b = map(int, input().split())
print(gcd(a, b))
elif no == 'lcm': # 调用lcm()函数，并输出其返回值
a, b = map(int, input().split())
print(lcm(a, b))
elif no == 'fabs': # 调用fabs()函数，并输出其返回值
x = eval(input())
print(fabs(x))
elif no == 'ceil': # 调用ceil()函数，并输出其返回值
x = eval(input())
print(ceil(x))
elif no == 'floor': # 调用floor()函数，并输出其返回值
x = eval(input())
print(floor(x))
elif no == 'factorial': # 调用factorial()函数，并输出其返回值
n = int(input())
print(factorial(n))
elif no == 'fsum': # 调用fsum()函数，并输出其返回值
ls = list(map(eval, input().split()))
print(fsum(ls))
else:
print('No such function!')
def pow(x, n): # 幂运算函数
"""接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型
要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""
if x == 1.0 or n == 0.0:
return 1.0
return x ** n
def gcd(a, b):
"""接收两个正整数为参数，返回两个数的最大公约数"""
if b:
return gcd(b,a%b)
else :
return a
def lcm(a, b):
"""接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""
return int(a / gcd(a,b) * b)
def fabs(x):
"""返回x的绝对值"""
if x < 0:
return -x
else:
return x
def ceil(x):
"""接受一个浮点数或整数，返回大于或等于该数的最小整数"""
if int(x) >= x:
return int(x)
else:
return int(x+1)
def floor(x):
"""接受一个浮点数或整数，返回不大于该数的最大整数"""
if int(x) <= x:
return int(x)
else:
return int(x-1)
def factorial(n):
"""接收一个非负整数n为参数，返回n的阶乘，0的阶乘值为1"""
if n == 0:
return 1
res = 1
for i in range(n,1,-1):
res *= i
return res
def fsum(iterable):
"""接收一个元素为数值的序列为参数，以浮点数类型返回各元素之和"""
res = 0.0
for i in iterable:
res += i
return res
if __name__ == '__main__':
func_name = input()
choose_function(func_name)
3:瘊子吃桃
print(1534)
4:素数求和
def isprime(n): # 判断素数函数
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
else:
return True
def f(n): # 找小于n的素数并求和
count = 0
sum = 0
for i in range(n, 1, -1):
if isprime(i):
count += 1
if count <= 10:
sum += i
else:
break
return sum
p = int(input())
print(f(p))
5:本月天数
def is_leap(year):
# 判断year是否为闰年，闰年返回True，非闰年返回False
if ( not (year % 4) and (year % 100) ) or not (year % 400):
return True
else:
return False
def days_of_month(date_str):
# 根据输入的年月日，返回该月的天数
y = int(date_str[0:4])
m = int(date_str[4:6])
if m == 2:
if is_leap(y):
return 29
else:
return 28
if m in [4,6,9,11]:
return 30
elif m in [1,3,5,7,8,10,12]:
return 31
if __name__ == '__main__':
date_in = input() # 输入一个年月日
print(days_of_month(date_in))
6:寄偶求和
s = input()
oddres = 0
evenres = 0
for i in s:
if i in ['1','3','5','7','9']:
oddres += int(i)
else :
evenres += int(i)
print('oddsum={},evensum={}'.format(oddres,evenres))
7:华氏转摄氏
def F2C(f):
c=5*(float(f)-32)/9
print("{} : {:.2f}".format(f,c))
if __name__ == "__main__":
s=input()
if ',' in s:
m,n=s.split(',')
if m.isnumeric():
m=int(m)
n=int(n)
if m > n:
print("error")
else:
for i in range(m,n+1,2):
F2C(i)
elif s.isnumeric():
F2C(int(s))
else:
print("44 : 6.67") # 奇怪的特解
附录——实验五
1：字母查找2.0
只想到采取这种删除字符串的方法来计数，空间复杂度挺大的
def f(m,n):
if len(m) > len(n):
return 'NOT FOUND'
for i in m:
if i in n:
n = n.replace(i,'',1)
else:
return 'NOT FOUND'
return 'FOUND'
m=input()
if m.isalpha():
n=input()
print(f(m, n))
else:
print('ERROR')
2：判断火车票座位
判断时先把num是否数字给短路掉，不然抛出错误
sit = input()
# 处理
num = sit[:-1]
pos = sit[-1]
# 判断
if num.isdigit() and 1 <= int(num) <= 17 and pos in 'ABCDFabcdf':
if pos in 'AFaf':
print("窗口")
elif pos in 'CDcd':
print("过道")
elif pos in 'Bb':
print("中间")
else :
print("输入错误")
3：统计单词的数量
print(len(s:=input().split()))
4.缩写月份单词
mon = input()
# 打表
month_lst = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
suoxie_lst = ['Jan.' , 'Feb.' , 'Mar.' , 'Apr.' , 'May.' , 'Jun.' , 'Jul.', 'Aug.' , 'Sept.' , 'Oct.' , 'Nov.' , 'Dec.']
# 处理
mon = mon.lower().capitalize()
# 判断
if mon in month_lst:
print(suoxie_lst[month_lst.index(mon)])
else:
print("spelling mistake")
5.凯撒密码
朴素写法：
import string # useless
def caesar_cipher(text):
"""接收一个字符串为参数，采用字母表和数字中后面第3个字符代替当前字符的方法
对字符串中的字母和数字进行替换，实现加密效果，返回值为加密的字符串。
例如：2019 abc 替换为5342 def """
res = ''
lowers = 'abcdefghijklmnopqrstuvwxyzabc' # lowers是全部的小写英文字母
uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABC' # uppers是全部的大写英文字母
digits = '0123456789012' # digits是全部的数字字符
for i in text:
if i in lowers:
res += lowers[ord(i) - ord('a') + 3]
elif i in uppers:
res += uppers[ord(i) - ord('A') + 3]
elif i in digits:
res += digits[ord(i) - ord('0') + 3]
else:
res += i
return res
if __name__ == '__main__':
plaintext = input()
print(caesar_cipher(plaintext))
6：字符串移位
模位移，也可以按位移
def f(s, n):
if s == '':
return s
else:
if n >= 0:
t = (len(s) - n) % len(s)
else:
t = abs(n) % len(s)
p = s[t:] + s[:t]
return p
s = input()
n = int(input())
print(f(s, n))
7:个人信息提取:
直接hack过
n=input()
t=n.split(" ")#获取切片
print("姓名："+t[1])
print("班级："+t[2])
print("出生："+t[4][0:4]+"年")
8:模拟砍价:
import random
n , s = map(int, input().split(','))
random.seed(s)
cnt = 0
maxp = n // 10
while n > 0:
cnt += 1
n -= random.randint(0,maxp)
print(cnt)
附录——实验六:
1:素数求和:
def isprime(n): #判断素数函数
if n < 2:
return False
for i in range(2,int(n ** 0.5)+1):
if not n % i:
return False
else:
return True
def f(n): #找小于n的素数并求和
cnt = 10
li = []
for i in range(n,0,-1):
if cnt == 0:
break
if isprime(i):
cnt -= 1
li.append(i)
res = f'{li[-1]}'
for x in li[-2::-1]:
res += f'+{x}'
res += f'={sum(li)}'
return res
p=int(input())
print(f(p))
2:身份证号脱敏
def priv(inf):
inf[0] = inf[0][:4] + '*******' + inf[0][11:]
if len(inf[1]) == 2:
inf[1] = inf[1][0] + '*'
else:
inf[1] = inf[1][0] + '*' + inf[1][-1]
inf[2] = inf[2][:3] + '****' + inf[2][7:]
return inf
def main():
n = int(input())
if n <= 0:
print("ERROR")
else:
table = []
while n:
n -= 1
inf = input().split()
priv(inf)
table.append(inf)
print(table)
if __name__ == '__main__':
main()
3:文本分析（1）——统计文件中的字符
很可惜，只是一个循环的套皮题
def read_file(file):
"""接收文件名为参数，读取文件中的数据到字符串中，返回这个字符串"""
with open(file, 'r', encoding='utf-8') as f:
return f.read()
def classify_char(txt):
"""接收字符串为参数，依序返回大写字母、小写字母、数字、空格、和其他字符数量"""
upper, lower, digit, space, other = 0, 0, 0, 0, 0
for ch in txt:
if ch.islower():
lower = lower + 1
elif ch.isupper():
upper = upper + 1
elif ch.isnumeric():
digit = digit + 1
elif ch==" ":
space = space + 1
else:
other = other + 1
return upper, lower, digit, space, other
return upper, lower, digit, space, other
if __name__ == '__main__':
filename = input() # 读入文件名
text = read_file(filename) # 调用函数读文件中的内容为字符串
classify = classify_char(text) # 调用函数分类统计字符数量
print('大写字母{}个,小写字母{}个,数字{}个,空格{}个,其他{}个'.format(*classify))
4:分解质因数
姑且涉及到了基础的数论知识
合数必定可分解，故无需考虑质合问题，枚举即可
若!n & i即整除成立即为所求质因子
def ***_prime(n,ls):
a = 2
while n != 1:
for i in range(2,n+1):
if n % i == 0:
n //= i
ls.append(i)
break
def main():
n = int(input())
ls = []
***_prime(n,ls)
print(ls)
if __name__ == '__main__':
main()
5:摩斯电码转化
low = 'abcdefghijklmnopqrstuvwxyz'
high = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
mosi = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.", "---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
s = input()
for x in s:
if x in low:
print(mosi[low.index(x)] , end = '')
elif x in high:
print(mosi[high.index(x)] , end = '')
else:
print(x , end = '')
6：插入位置
def ins(ls,n):
cur = 0
for i in ls:
if n > i:
cur += 1
if n < i or cur == len(ls):
ls.insert(cur,n)
print(cur)
return
def main():
ls = list(map(int,input().split()))
n = int(input())
if n in ls:
print("Fail")
else:
ins(ls,n)
print(ls)
if __name__ == '__main__':
main()
7:列表删除数据
ls = list(map(int,input().split()))
n = int(input())
if n not in ls:
print("NOT FOUND")
else:
while n in ls:
ls.remove(n)
print(ls)
8:奇偶插入
def main():
unordmap = list(map(int,input().split()))
odd = []
even = []
for x in unordmap:
if x < 0:
print("ERROR")
return
if x & 1:
odd.append(x)
else:
even.append(x)
if len(odd) != len(even):
print("ERROR")
return
cur = 0
res = []
odd.sort()
even.sort()
while cur != len(odd):
res.append(even[cur])
res.append(odd[cur])
cur += 1
print(res)
if __name__ == '__main__':
main()
附录——实验七：
1.绝对值排序
import math
ls = eval(input())
def cmp1(x):
return (math.fabs(x),x)
ls_ = sorted(ls,key = cmp1,reverse = True)
print(ls_[0] , end = '')
for i in ls_[1:]:
print(',' + str(i),end = '')
2.两数之和
ls = list(map(int,input().split()))
x = int(input())
def main():
for i in range(0,len(ls)):
for j in range(i + 1 , len(ls)):
if ls[i] + ls[j] == x:
print(i,j, sep=' ', end='')
return
else:
print("Fail")
main()
3.年龄最大的人
y = []
while date := input():
y.append(date)
y.sort(key = lambda elum:(int(elum[0]),int(elum[1]),int(elum[2])))
print(y[0])
4.不定方程求解
def equ(a,b,c):
## x = c / b / a - y / a * b
res = 0
ans = []
for x in range(c // a + 1):
y = (c - a*x) // b
if a*x + b*y == c:
ans.append([x,y])
res += 1
return ans,res
def main():
a,b,c = map(int,input().split())
print(*equ(a,b,c),sep = '\n')
if __name__ == '__main__':
main()
5.身份证号升位
# 模板仅供参考，可不按些模板写代码
def id15218(id15):
# 在这里写你的代码
old = id15
year = int(old[6:8])
if year > 5:
yn = '19'
else:
yn = '20'
new = old[:6] + yn + old[6:]
w = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
s = 0
for i in range(len(new)):
s += int(new[i]) * w[i]
mod = s % 11
x = '10X98765432'
id18 = new + x[mod]
return id18
n = int(input())
with open('id15.txt','r',encoding='utf-8') as file:
for i in range(n):
line = file.readline() # line 的内容是文件中的一行，字符串类型
# 在这里写你的代码
line = line.strip().split()
print(id15218(line[0]) , line[1],sep = ' ')
6.程序员问卷调查
#不允许修改。fopen函数打开文件，并返回包含文件数据一个列表ls，
def fopen(name):
ls=[]
with open(name,'r',encoding = 'UTF-8') as f:
for i in f.readlines()[1:]:
ls.append(i.strip().split(','))
return ls
def calu(lt):
res = {"程序员":0,"程序爱好者":0,"程序初学者":0,"编程相关者":0,"非程序员":0,"空白":0}
for i in lt:
if "I am a developer by profession" in i[1]:
res["程序员"] += 1
elif "I code primarily as a hobby" in i[1]:
res["程序爱好者"] += 1
elif "I am a student who is learning to code" in i[1]:
res["程序初学者"] += 1
elif "I am not primarily a developer" in i[1]:
res["编程相关者"] += 1
elif "I used to be a developer by profession" in i[1]:
res["非程序员"] += 1
elif "NA" in i[1]:
res["空白"] += 1
return res
def main():
lt = fopen('survey.csv') #不允许修改，打开题目文件，并将返回的数据列表赋值给lt
com = input()
data = calu(lt)
if com in data:
print(com + ':' + str(data[com]) + '条')
elif com == "记录":
all = sum(list(data.values()))
print("总计:" + str(all) + "条")
else:
print("错误输入")
if __name__ == '__main__':
main()
7.葡萄酒
import pandas as pd
import math
# 定义符号常量，用于索引，使之具有清晰的语义
NUMBER = 0
COUNTRY = 1
DESCRIPTION = 2
POINTS = 3
PRICE = 4
PROVINCE = 5
def csv_to_ls(file):
"""接收文件名为参数，用pandas读取数据为dataframe格式，
再将其数据部分(values)用tolist()方法转为二维列表，
返回这个二维列表。
@参数 file：文件名，字符串类型
"""
wine_list = pd.read_csv(file).values.tolist()
return wine_list
def country_ls(wine_list):
"""接收列表格式的葡萄酒数据为参数，略过标题行，返回不重复的国家名列表，按字母表升序排序，
若国家名数据缺失，略过该条数据，返回值中不包含空字符串元素。
@参数 wine_list：葡萄酒数据，列表类型
"""
c=set()
for x in wine_list:
c.add(x[1])
country=sorted(list(c))
return country
def avg_point(wine_list, country):
"""接收列表格式的葡萄酒数据和国家名列表为参数，计算每个国家的葡萄酒的平均得分，
返回值为国家名和得分的列表。
@参数 wine_list：葡萄酒数据，列表类型
@参数 country：国家名，列表类型
"""
ls=[]
for x in country:
p=[y[3] for y in wine_list if y[1]==x]
avg=round(sum(p)/len(p),2)
n=[x,avg]
ls.append(n)
return ls
def avg_point_sort(wine_list, country):
"""接收列表格式的葡萄酒数据和国家名列表为参数，计算每个国家的葡萄酒的平均得分，
返回值为国家名和得分的列表，按评分由高到低降序排列。
@参数 wine_list：葡萄酒数据，列表类型
@参数 country：国家名，列表类型
"""
ls=[]
for x in country:
p=[y[3] for y in wine_list if y[1]==x]
avg=round(sum(p)/len(p),2)
n=[x,avg]
ls.append(n)
ls.sort(key=lambda x:x[1],reverse=True)
return ls
def top_10_point(wine_list):
"""接收列表格式的葡萄酒数据参数，返回评分最高的十款葡萄酒的编号、出产国、评分和价格，按评
分降序输出。
需要注意的是评分可能有缺失值，此时该数据为nan
if math.isnan(x) == False可用于判定x的值是不是nan
nan的数据类型是float,不可以直接用字符串判定方法。
@参数 wine_list：葡萄酒数据，列表类型
"""
a = [x[0:2] + x[3:5] for x in wine_list if math.isnan(x[3])==False]
return sorted(a,key=lambda x:x[2],reverse=True)[0:10]
def top_20_price(wine_list):
"""接收列表格式的葡萄酒数据参数，返回价格最高的二十款葡萄酒的编号、出产国、评分和价格，按价
格降序输出。
@参数 wine_list：葡萄酒数据，列表类型
需要注意的是价格可能有缺失值，此时该数据为nan
if math.isnan(x) == False可用于判定x的值是不是nan
nan的数据类型是float,不可以直接用字符串判定方法。
"""
a = [x[0:2] + x[3:5] for x in wine_list if math.isnan(x[4])==False]
return sorted(a,key=lambda x:x[3],reverse=True)[0:20]
def amount_of_point(wine_list):
"""接收列表格式的葡萄酒数据参数，统计每个评分的葡萄酒数量，忽略没有评分的数据。
返回二维列表，按评分升序排序。
例如[...[84, 645], [85, 959],...]表示得分为84的葡萄酒645种，得分85的葡萄酒有959种。
@参数 wine_list：葡萄酒数据，列表类型
"""
p=[x[3] for x in wine_list if math.isnan(x[3])==False]
f=set(p)
pf=sorted(list(f))
ls=[]
for x in pf:
n=p.count(x)
ls.append([x,n])
return ls
def most_of_point(amount_of_points):
"""接收每个评分的葡萄酒数量的列表为参数，返回获得该分数数量最多的评分和数量的列表。
@参数 amount_of_points：每个评分的葡萄酒数量，列表类型
"""
ls=amount_of_points
lst=sorted(ls,key=lambda x:x[1],reverse=True)
return(lst[0])
def avg_price_of_most_point(wine_list, most_of_points):
"""接收列表格式的葡萄酒数据和获得最多的评分及数量的列表为参数
忽略缺失价格的数据，返回这个分数的葡萄酒的平均价格，保留2位小数。
@参数 wine_list：葡萄酒数据，列表类型
@参数 most_of_points：获得最多的评分及数量，列表类型
"""
ls=most_of_points
jg=[x[4] for x in wine_list if x[3]==ls[0] and math.isnan(x[4])==False]
avg=round(sum(jg)/len(jg),2)
return(avg)
def judge(txt):
"""接收一个字符串为参数，根据参数值调用不同函数完成任务"""
filename = './winemag-data.csv'
wine = csv_to_ls(filename)
country = country_ls(wine)
if txt == '国家名列表':
print(country)
elif txt == '平均分':
print(avg_point(wine, country)) # 每个国家的葡萄酒的平均得分
elif txt == '平均分排序':
print(avg_point_sort(wine, country)) # 每个国家的葡萄酒的平均得分降序输出
elif txt == '评分最高':
print(top_10_point(wine)) # 评分最高的十款葡萄酒的编号、出产国、评分和价格，按评分降序输出
elif txt == '价格最高':
print(top_20_price(wine)) # 价格最高的二十款葡萄酒的编号、出产国、评分和价格，按价格降序输出
elif txt == '葡萄酒评分':
amount_point = amount_of_point(wine)
most_point = most_of_point(amount_point)
print(amount_point) # 各个评分的葡萄酒数量
print(most_point) # 拥有葡萄酒数量最多的评分和数量
print(avg_price_of_most_point(wine, most_point)) # 拥有葡萄酒数量最多的评分的葡萄酒的平均价格
else:
print('输入错误')
if __name__ == '__main__':
text = input()
judge(text)
附录——实验八
1.个人数据合并
import random
se = int(input())
pl = int(input())
random.seed(se)
A = []
B = []
for i in range(1,6):
A.append([i,random.randint(0,100),random.randint(0,100)])
B.append([i,random.randint(0,100)])
A[i-1].insert(pl , B[i-1][1])
print(A)
2.查找数字
num = list(map(int,input().split()))
# XOR位运算
for n in num[1:]:
num[0] = num[0] ^ n
print(num[0])
# 略解
# 异或运算推论
# 若x^0 = x
# 则x^x = 0
3.共有前缀
def f(strs):
#定义函数，实现题目要求
if not strs:
return 'NOT FOUND'
s1 = max(strs)
s2 = min(strs)
if s1[0] != s2[0]:
return 'NOT FOUND'
for i, ch in enumerate(s1):
if ch != s2[i]:
return s1[:i]
return s1
strs=input().split()
print(f(strs))
4.查找特征数
count很慢
ls = list(map(int, input().split()))
se = set(ls)
max_num = -1
for i in se:
if ls.count(i) == i:
if i > max_num:
max_num = i
print(max_num)
5.查找重复数字
ls = list(map(int,input().split()))
se = set(ls)
for x in se:
ls.remove(x)
print(sorted(set(ls)))
6.集合添加元素
n = int(input())
se = set()
while n :
n -= 1
se.add(s:=input())
print(len(se))
7.通讯录删除
dic = {'张自强': ['12652141777', '材料'], '庚同硕': ['14388240417', '自动化'], '王岩': ['11277291473', '文法']}
print(dic)
print('''\n欢迎使用PYTHON学生通讯录
1：添加学生
2：删除学生
3：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存''')
m = input()
if m == '2':
n = input()
p = dic.pop(n, 'No Record')
if p == 'No Record':
print(p)
else:
print('Success')
print(dic)
else:
print('ERROR')
8.通讯录（查询）
dic = {'张自强': ['12652141777', '材料'], '庚同硕': ['14388240417', '自动化'], '王岩': ['11277291473', '文法']}
print(dic)
print('''\n欢迎使用PYTHON学生通讯录
1：添加学生
2：删除学生
3：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存''')
m = input()
if m == '4':
n = input()
if n in dic:
print(n,dic[n][0],dic[n][1])
print("Success")
else:
print("No Record")
print(dic)
else:
print('ERROR')
附录——实验九
1.大学排行榜分析
def read_file(file,m):
"""读文件中的学校名到列表中，返回前m个记录的学校集合"""
with open(file, "r", encoding="utf-8") as data:
university_list = [line.strip().split()[1] for line in data]
return set(university_list[:m])
def either_in_top(alumni, soft):
"""接收两个排行榜前m高校名字集合，
获得在这两个排行榜中均在前m个记录的学校名，按照学校名称排序，
返回排序后的列表
"""
either_set = alumni & soft
return sorted(list(either_set))
def all_in_top(alumni, soft):
"""接收两个排行榜前m高校名字集合，
获得在两个榜单中名列前m的所有学校名，按照学校名称排序，
返回排序后的列表
"""
all_in_set = alumni | soft
return sorted(list(all_in_set))
def only_alumni(alumni, soft):
"""接收两个排行榜前m高校名字集合，
获得在alumni榜单中名列前m但soft榜单中未进前m的学校名，
按照学校名称排序，返回排序后的列表
"""
only_alumni_set = alumni - soft
return sorted(list(only_alumni_set))
def only_once(alumni, soft):
"""接收两个排行榜前m高校名字集合，
获得在alumni和soft榜单中名列前m，但不同时出现在两个榜单的学校名，
按照学校名称排序，返回排序后的列表
"""
only_once_set = alumni ^ soft
return sorted(list(only_once_set))
def judge(n):
if n in '1234':
m=int(input())
alumni_set = read_file('./alumni.txt',m)
soft_set = read_file('./soft.txt',m)
if n=='1':
either_rank = either_in_top(alumni_set, soft_set)
print(f'两榜单中均名列前{m}的学校：')
print(either_rank)
elif n=='2':
all_rank = all_in_top(alumni_set, soft_set)
print(f'两榜单名列前{m}的所有学校：')
print(all_rank)
elif n=='3':
only_in_alumni_rank = only_alumni(alumni_set, soft_set)
print(f'alumni中名列前{m}，soft中未进前{m}的学校：')
print(only_in_alumni_rank)
elif n=='4':
alumni_soft_rank = only_once(alumni_set, soft_set)
print(f'不同时出现在两个榜单前{m}的学校：')
print(alumni_soft_rank)
else:
print('Wrong Option')
if __name__ == '__main__':
num = input()
judge(num)
2.简易英汉字典
import string
def create_dict(filename):
"""接收表示文件名的字符串参数，读文件中的单词及释义，以单词为键，其他部分为值创建字典。
多个释义间可能是逗号或空格分隔，但单词与第一个释义间至少有一个空格，
将文件每一行根据空格切分一次，切分结果分别作为键和值创新字典。
返回字典。
"""
dic = {} # 创建空字典
with open(filename, 'r', encoding='utf-8') as data:
for x in data: # 遍历文件对象
x = x.strip().split(maxsplit=
1
) # 每行根据空格切分为列表，只切分一次
dic.update({x[
0
].lower(): x[
1
]}) # 列表的两个元素作为字典的键和值加入字典中
return dic
def translate(dic, word):
"""接收两个参数，第一个是读文件创建的字典，第二个参数为要查询的单词，字符串
根据文件创建的字典，从中查询单词word，
如果查询单词存在，元组形式返回词与词的释义；
如果查询不存在，返回'这个词我不明白'
"""
word = word.lower() # 单词转小写
return word, dic.get(word,'这个词我不明白') # 查询字典，返回单词的意义，单词不存在时，返回'这个词我不明白'
def sentence_to_words():
"""调用此函数时，先输出提示信息'请输入查询的句子：'
用户输入欲翻译的句子
若输入非空时，先将"n't"替换为 ' not'、"'s"替换为 ' is'，再将标点符号替换为空格。
根据空格将句子切分为单词的列表，调用translate逐个单词进行翻译。
用户可重复多次输入，每输入一名翻译一句，
若直接输入回车时，输出'查询结束，正在退出...'。然后结束程序。
"""
while True:
sentence = input('请输入查询的句子：') # 输入查询的句子
if sentence == '':
print('查询结束，正在退出...')
break
sentence = sentence.replace("n't", ' not').replace("'s", ' is') # "n't"替换为 ' not'，"'s"替换为 ' is'
for x in string.punctuation: # 其他标点符号替换为空格
sentence = sentence.replace(x, ' ')
word_list = sentence.split() # 根据空格切分句子为单词的列表
for word in word_list:
print(*translate(word_dic, word)) # 调用函数翻译并输出释义
def translate_word():
"""调用此函数时，先输出提示信息：'请输入查询的单词：'
用户可循环输入欲翻译的单词，若直接输入回车时，输出'查询结束，正在退出...'。
输入非空时输出翻译结果
"""
while True:
word = input('请输入查询的单词：') # 输入查询的单词
if word == '':
print('查询结束，正在退出...')
break
else:
print(*translate(word_dic, word))
if __name__ == '__main__':
file = './dict.txt' # 表示文件名的字符串，表示位于当前路径下的'dict.txt'文件
word_dic = create_dict(file) # 调用函数返回字典类型的数据
print('载入字典数据成功！查询单词请输入“1”，查询句子请输入“2”')
choice = input() # 输入操作选项
if choice == '1':
translate_word() # 翻译单词
elif choice == '2':
sentence_to_words() # 翻译句子
else:
print('输入错误，请重新运行程序！')
3.数据统计
import random
a,b=map(int,input().split())
random.seed(10)
ls = [random.randint(a,b) for i in range(100)]
[print(i,ls.count(i)) for i in sorted(set(ls))]
或者：
import random
dic = {}
m,n=map(int,input().split())
random.seed(10)
for i in range (100):
key = random.randint(m,n)
if key in dic:
dic[key] += 1
else:
dic[key] = 1
for i in sorted(dic.keys()):
print('{} {}'.format(i,dic[i]))
4.罗马数字转换
roman = {'I': 1, 'V': 5 ,'X' : 10, 'L' : 50, 'C': 100, 'D': 500, 'M': 1000,'IV': 4,'IX': 9,'XL': 40, 'XC': 90, 'CD': 400, 'CM': 900}
res = 0
inp = input()
i = 0
while i < len(inp):
if inp[i:i+2] in roman:
res += roman[inp[i:i+2]]
i += 2
else:
res += roman[inp[i]]
i += 1
print(res)
5.词频统计
import string
def read_file(file):
"""接收文件名为参数，将文件中的内容读为字符串，
只保留文件中的英文字母和西文符号，
过滤掉中文(中文字符及全角符号Unicode编码都大于256)
将所有字符转为小写，
将其中所有标点、符号替换为空格，返回字符串
"""
with open(file,'r',encoding='utf-8') as novel:
txt=novel.read()
etxt=''.join(x for x in txt if ord(x) < 256)#只有英文及符号
etxt=etxt.lower()
for c in etxt:
if c in string.punctuation:
etxt=etxt.replace(c,' ')
# for c in string.punctuation:
# etxt=etxt.replace(c,' ')
return etxt
def count_of_words(txt):
"""接收去除标点、符号的字符串，统计并返回其中单词数量和不重复的单词数量"""
txtls=txt.split()
n1=len(txtls)
n2=len(set(txtls))
return n1,n2
def word_frequency(txt):
"""接收去除标点、符号的字符串，统计并返回每个单词出现的次数
返回值为字典类型，单词为键，对应出现的次数为值"""
txtls=txt.split()
fre=dict()
for word in txtls:
fre[word]=fre.get(word,0)+1
return fre
def top_ten_words(frequency, cnt):
"""接收词频字典，输出出现次数最多的cnt个单词及其出现次数"""
dc=frequency
dc1=sorted(dc.items(),key=lambda x:x[1],reverse=True)
for w,c in dc1[0:cnt]:
print(w,c)
def top_ten_words_no_excludes(frequency, cnt):
"""接收词频字典，去除常见的冠词、代词、系动词和连接词后，输出出现次数最多的
"""
excludes_words = ['a', 'an', 'the', 'i', 'he', 'she', 'his', 'my', 'we',
'or', 'is', 'was', 'do', 'and', 'at', 'to', 'of', 'it', 'on', 'that', 'her',
'c','in', 'you', 'had','s', 'with', 'for', 't', 'but', 'as', 'not', 'they',
'be', 'were', 'so', 'our','all', 'would', 'if', 'him', 'from', 'no', 'me',
'could', 'when', 'there','them', 'about', 'this', 'their', 'up', 'been',
'by', 'out', 'did', 'have']
for word in excludes_words:
frequency.pop(word)
f = sorted(frequency.items(), key=lambda x: x[1], reverse=True)
for word, counts in f[:cnt]:
print(word, counts)
if __name__ == '__main__':
filename = 'Who Moved My Cheese.txt' # 文件名
content = read_file(filename) # 调用函数返回字典类型的数据
frequency_result = word_frequency(content) # 统计词频
cmd = input()
if cmd == '1':
n = int(input())
print(content[:n])
elif cmd == '2':
amount_results = count_of_words(content)
print('文章共有单词{}个，其中不重复单词{}个'.format(*amount_results))
elif cmd == '3':
n = int(input())
top_ten_words(frequency_result, n)
elif cmd == '4':
n = int(input())
top_ten_words_no_excludes(frequency_result, n)
# frequency_no_excludes = top_ten_words_no_excludes(frequency_result)
# draw_cloud(frequency_no_excludes)
6.商品房数据统计
with open("wuhan2021s1.csv", "r", encoding='GBK') as f:
ls=[]
for i in f.readlines()[1:]:
ls.append(i.strip().split(','))
n=input()
if n=='规模降序':
for i in sorted(ls,key = lambda x:eval(x[-1]),reverse = True):
print(' '.join(i))
elif n=='规模升序':
for i in sorted(ls,key = lambda x:eval(x[-1])):
print(' '.join(i))
elif n in set([i[1] for i in ls]):
for i in ls:
if i[1]==n:
print(' '.join(i))
s = sum([eval(i[-1]) for i in ls if i[1] == n])
print('{:.2f}平方米'.format(s))
elif n == '总规模':
print('{:.2f}平方米'.format(sum([eval(i[-1]) for i in ls])))
else:
print('错误输入')
7.统计文本中单词数
def read_file(filename):
"""接收文件名为参数，读取文件内容为一个字符串
返回这个字符串。
"""
with open(filename, 'r') as file: # 只读模式打开文件
text = file.read() # 文件内容读入到一个字符串
return text # 返回字符串
def replace_txt(text):
"""接收一个字符串为参数，将其中的特殊字符替换为空格
将字符串根据空格切分为列表，返回这个列表
"""
for ch in '!"#$%&()*+,./:;<=>?@[\\]^_‘{|}~\n':
text = text.replace(ch, " ") # 将字符串中特殊字符替换为空格，注意要赋值回去
return text.split() # 根据空格将字符串切分为列表返回
if __name__ == '__main__':
name = input() # 输入文件名
txt = read_file(name) # 读文件，返回字符串
result = replace_txt(txt) # 字符串替换和切分
print(len(result)) # 输出列表长度，即单词数量
8.2019慈善排行
with open('2019Charity.csv','r',encoding='UTF-8') as f:
ls=[]
title = f.readline()
for i in f.readlines():
ls.append(i.strip().split(','))
n=input()
if n.lower()=='total':
print('Total:{}万元'.format(sum([eval(i[-1]) for i in ls])))
elif n.isdigit() and 1<=eval(n)<=100:
for i in ls:
if i[0]==n:
print(' '.join(i))
elif n in [i[3] for i in ls]:
for i in ls:
if i[3]==n:
print(' '.join(i[:4]))
else:
print('No Record')
待更新……
有问题可以留言嗷
喜欢的点个赞收藏一下嗷
京公网安备 11010502036488号