目录
文本分析与加密
类型：字符串
描述
读取文件中的内容为字符串可以用以下函数实现：
# 读文件，返回字符串，file为文件名变量，若为文件名时，须为字符串类型
def read_file(file):
with open(file, 'r', encoding='utf-8') as f:
return f.read() # 返回值为字符串
读取附件中的文件，完成以下操作：
1.分类统计文件中大写字母、小写字母、数字、空白字符（包括空格、\n、\t等，可用isspace()方法判断）和其他字符的数量
2.输出文件中单词的数量（将其中所有标点符号替换为空格，再根据空格对字符串进行切分可以得到元素为单词的列表。数字按单词统计，如“ 1994” 计算一个单词）
3.用恺撒加密方法对上述文件内容进行加密，为提高加密强度，约定输入一个秘密单词来产生偏移量，偏移量计算方法为先计算用户输入的字符串中每个字符的ASCII值的和，再对26取模，结果作为偏移量。为避免偏移量恰好为0，本题约定秘密单词为用于表示星期几的单词，即'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'中的一个。
在密码学中，凯撒密码是一种最简单且最广为人知的加密技术。“恺撒密码”据传是古罗马恺撒大帝用来保护重要军情的加密系统。它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推，小写字母也一样处理，其他字符忽略，不作任何改变。
输入格式
一个代表星期几的单词，'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'中的一个
输出格式
依序输出：
1.文件中大写字母、小写字母、数字、空白字符和其他字符的数量
2.文件中单词的数量
3.偏移量
4.用恺撒加密方法对上述文件内容进行加密的结果
示例 1
输入：
Tuesday
输出：
16 306 11 84 17
共有86单词
7
Ayplk 3 aptlz mvy bupclyzpaf. Hss mhpslk.
P hwwsplk mvy Ohychyk mvy 10 aptlz. Hss mhpslk, aolf kvu’a lclu dhua av zll tl.
Mvy aol shza aptl, P dlua av aol alhjolyz’ jvsslnl dopjo dhz jvuzpklylk aol aopyk vy mvbyao jshzz vm tf jpaf.
P hwwsplk qviz mvy 30 aptlz. Nva ylqljalk.
Pa dhz zv kpmmpjbsa ha aoha aptl, P dhz zv mybzayhalk.
Iljhbzl P ahbnoa pu aol bupclyzpaf. Tf whf dhz $10 h tvuao.
Iljhbzl P jvbsk uva mpuk h nvvk qvi pu 1994.
附件 程序内如何读取附件？
| mayun.txt |
代码：
个人
a = input()
n = 0
for i in a:
n = n + ord(i)
n = n%26
f = open('mayun.txt', 'r', encoding='utf-8')
s = list(f.read())
s1 = ''
daxie = 0
xiaoxie = 0
shuzi = 0
kongbai = 0
qita = 0
L = len(s)
for i in range(L):
if(s[i].isupper()):
daxie = daxie + 1
if(ord('Z')-n+1<=ord(s[i])<=ord('Z')):
s1 = s1 + chr(ord(s[i]) + n -26)
else:
s1 = s1 + chr(ord(s[i]) + n)
elif(s[i].islower()):
xiaoxie = xiaoxie + 1
if(ord('z')-n+1<=ord(s[i])<=ord('z')):
s1 = s1 + chr(ord(s[i]) + n -26)
else:
s1 = s1 + chr(ord(s[i]) + n)
elif(s[i].isdigit()):
shuzi = shuzi + 1
s1 = s1 + s[i]
elif(s[i].isspace()):
kongbai = kongbai + 1
s1 = s1 + s[i]
s[i] = ' '
else:
qita = qita + 1
s1 = s1 + s[i]
s[i] = ' '
s = ''.join(s)
s = s.split()
print(daxie,xiaoxie,shuzi,kongbai,qita)
print("共有{}单词".format(len(s)))
print(n)
print(s1)答案
# -------- ------- --------
# @Author : 赵广辉
# @Contact: vasp@qq.com
# @Company: 武汉理工大学
# @Version: 1.0
# @Modify : 2022/06/13 11:33
# Python程序设计基础，赵广辉，高等教育出版社，2021
# Python程序设计基础实践教程，赵广辉，高等教育出版社，2021
# -------- ------- --------
import string
# 读文件，返回字符串
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.isspace():
space = space + 1
else:
other = other + 1
return upper, lower, digit, space, other
# 用空格替换所有符号，切分为列表
def word_list(txt):
for ch in '!"#$%&()*+,-.:;<=>?@[\\]^_’‘{|}~/':
txt = txt.replace(ch, " ") # 所有符号替换为空格
# print(txt)
return txt.split() # 切分为列表，返回列表
# 返回单词数量
def number_of_words(ls):
total_words = len(ls) # 列表长度
return total_words # 列表长度即单词个数
# 用字符串中字符ASCII值的和对26取模为偏移量
def offset_cal(day):
sum_of_ch = 0
for c in day:
sum_of_ch = sum_of_ch + ord(c)
offset = sum_of_ch % 26
return offset
def kaisa(txt, number):
lower = string.ascii_lowercase # 小写字母
upper = string.ascii_uppercase # 大写字母
before = string.ascii_letters
after = lower[number:] + lower[:number] + upper[number:] + upper[:number]
table = ''.maketrans(before, after) # 创建映射表
return txt.translate(table)
if __name__ == '__main__':
filename = 'mayun.txt' # 读取的文件名
text = read_file(filename) # text为字符串
words_list = word_list(text) # 单词的列表
words_counts = number_of_words(words_list)
# weeks = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
secret_word = input()
offset_number = offset_cal(secret_word)
print(*classify_char(text))
print(f'共有{words_counts}单词')
print(offset_number)
print(kaisa(text, offset_number))蒙特卡洛法求圆周率（turtle动画）
类型：流程控制
描述
用蒙特卡洛方法计算圆周率π的原理如下：
一个边长为2r的正方形内部相切一个半径为r的圆，圆的面积是πr2，正方形的面积为4r2，二者面积之比是π/4，因为比值与r大小无关，所以可以假设半径 r的值为1。
在这个正方形内部，随机产生n个点（x,y），当随机数较多时，可以认为这些点服从均匀分布的规律。计算每个点与中心点的距离是否大于圆的半径(x2+y2>r2)，以此判断是否落在圆的内部。统计圆内的点数，与n的比值乘以4，就是π的值。理论上，n越大，计算的π值越准，但由于随机数不能保证完全均匀分布，所以蒙特卡洛法每次计算结果可能不同。
turtle库中的goto(x,y)可以直接到坐标(x,y)处，利用turtle库，结合蒙特卡洛方法绘制本实验项目中蒙特卡洛方法的图。
import random
import turtle # 导入turtle库
def monte_carlo_pi_turtle(n):
"""接收正整数为参数，利用蒙特卡洛方法计算圆周率
利用turtle绘制一个正方形和其内接圆
随机产生一对坐标，判定是否落在圆内，圆内的点用红色绘制，圆外的点用蓝色绘制"""
turtle.tracer(1000) # 刷新间隔,提高绘制速度
#=======================================================
# 补充你的代码
#=======================================================
turtle.hideturtle() # 隐藏光标
turtle.update() # 刷新
turtle.done() # 结束绘制
if __name__ == '__main__':
times = int(input()) # 输入随机次数
monte_carlo_pi_turtle(times) # 调用函数绘图
输入格式
一个正整数n，表示蒙特卡洛法求圆周率时产生的随机点的个数。
输出格式
turtle图。
示例
无。
代码：
个人
import random
import turtle as t # 导入turtle库
def monte_carlo_pi_turtle(n):
"""接收正整数为参数，利用蒙特卡洛方法计算圆周率
利用turtle绘制一个正方形和其内接圆
随机产生一对坐标，判定是否落在圆内，圆内的点用红色绘制，圆外的点用蓝色绘制"""
t.tracer(1000) # 刷新间隔,提高绘制速度
k = 300 # 放大倍数；绘图过程中图不能太小，会看不清
s = 0
# 绘制圆框
t.up()
t.fd(k)
t.pd()
t.lt(90)
t.pensize(2)
t.pencolor('green')
t.circle(k)
# 绘制方框
t.pencolor('black')
t.fd(k)
for i in range(4):
t.lt(90)
t.fd(2*k)
t.up()
# 绘制点图
for i in range(n):
x = random.uniform(-1,1)
y = random.uniform(-1,1)
t.goto(k*x,k*y)
if(x*x+y*y<1):
t.dot(5,'red') # 圆里画红点
s = s + 1
else:
t.dot(5,'blue') # 圆外画蓝点
t.update() # 刷新
print(4*s/n) # 输出计算的π值
t.hideturtle() # 隐藏光标
t.update() # 刷新
t.done() # 结束绘制
if __name__ == '__main__':
times = int(input()) # 输入随机次数
monte_carlo_pi_turtle(times) # 调用函数绘图答案
import random
import turtle # 导入turtle库
# 给出turtle模板，学生填monte_carlo代码，帮助学生理解算法，了解turtle绘图
def monte_carlo_pi_turtle(n):
# random.seed(10)
turtle.tracer(1000) # 刷新间隔,提高绘制速度
turtle.pensize(4)
turtle.penup()
turtle.goto(-300, -300)
turtle.pendown()
for i in range(4):
turtle.forward(600)
turtle.left(90)
turtle.forward(300)
turtle.pencolor('green')
turtle.circle(300)
hits = 0 # 落在圆内的计数器初值设为 0
for i in range(1, n + 1):
x, y = random.uniform(-1, 1), random.uniform(-1, 1), # 生成两个随机数模拟一个点的坐标
pos = (x ** 2 + y ** 2) ** 0.5 # 计算坐标（x,y）到原点的距离
if pos <= 1.0: # 如果距离小于等于1，点在圆内
hits = hits + 1
turtle.pencolor('red') # 落在圆内在点颜色用红色
else: # 如果距离大于1，点在圆外
turtle.pencolor('blue') # 落在圆内在点颜色用蓝色
turtle.penup()
turtle.goto(x * 300, y * 300) # 画笔抬起并移动到数值放大400倍的x,y处
turtle.pendown()
turtle.dot(5) # 画一个半径为 3 的圆点
if i % 10000 == 0: # 实验为10000的倍数次时
turtle.pencolor('black')
pi = 4 * (hits / i) # 根据落在圆内外的点数量估算PI值
turtle.penup() # 画笔抬起
turtle.goto(320, 150 - i // 1000 * 30) # 移动到区域外记录当前PI值
turtle.pendown() # 画笔抬起
turtle.write("{}次时PI的值是{:.4f}".format(i, pi), font=("宋体", 18, "normal"))
turtle.update() # 刷新
turtle.hideturtle() # 隐藏光标
turtle.update() # 刷新
turtle.done() # 结束绘制
if __name__ == '__main__':
times = int(input()) # 输入随机次数
monte_carlo_pi_turtle(times) # 调用函数绘图csv文件排序输出
描述：
读入grade0.csv文件，按照要求对第i列升序排列后输出。(提示：可以使用语句fo=open('grade0.csv','r',encoding='UTF-8')来打开文件。)
Grade0.csv文件的内容形如下图：
输入格式：
输入为一个数正整数 i，要求根据 grade0.csv 文件的第 i 列值升序排列后输出文件中的数据，当第 i 列数据值相同时，按第 1 列数据的值辅助排序（测试数据保证为正整数且不超过数据列数）。
输出格式：
按行输出排序后的信息，数据列之间用tab（‘\t’）分隔，最后一列后面没有空格。
输入输出示例
| 输入 | 输出 | |
| 示例 1 | 4 | 20170101 章阳 Male A 20170102 徐芳 Female A 20170112 胡瑞欣 Female A 20170113 田益宾 Male A 20170115 张铭武 Male A 20170106 周思云 Female B 20170109 刘春燕 Female B 20170110 刘兴怡 Female B |
附件 程序内如何读取附件？
| grade0.csv |
代码：
个人
f = open('grade0.csv','r',encoding='UTF-8')
ls = []
for line in f:
ls.append(line.strip('\n').split(','))
i = eval(input())
ls.sort(key = lambda x:x[0])
ls.sort(key = lambda x:x[i-1])
for line in ls:
print('\t'.join(line))答案
def csv_to_lst(filename):
"""接收文件名为参数，读取数据到二维列表中，返回二维列表。形如
[['20170101', '章阳', 'Male', 'A'],... ['20170108', '刘忆宁', 'Male', 'E']]
"""
with open(filename, 'r', encoding='UTF-8') as f:
grade_in_lst = [line.strip().split(',') for line in f] # 逐行切分为列表，得到二维列表
return grade_in_lst
def sort_lst(list_name, n):
"""接收需要排序的二维列表名和整数的排序列序号（范围为：1，2，3，4）为参数，返回排序后的二维列表。"""
list_name.sort(key=lambda x: x[n - 1]) # 列序号从1开始，列表中的序列从0开始，排序依据用x[n - 1]
return list_name # 返回排序后的列表
def output(ls):
"""接收排序后的二维列表为参数，逐行输出，每行的元素间用制表符分隔。"""
for line in ls: # line 为子列表
print(*line, sep='\t') # *对子列表进行解包，得到多个元素，sep指定分隔符
if __name__ == '__main__':
file = 'grade0.csv'
num = int(input())
grade_list = csv_to_lst(file)
ls_in_sort = sort_lst(grade_list, num)
output(ls_in_sort)不定方程求解
类型：列表元组
描述
给定正整数a,b,c，求不定方程ax+by=c关于未知数x和y的所有非负整数解组数并输出。部分用例有时间限制。
输入格式
输入为一行，包含三个正整数a、b、c，两个整数之间用单个空格隔开，每个数均不大于10000.
输出格式
第一行以二维列表的形式输出所有的非负整数解
第二行输出一个整数，即不定方程的非负整数解组数
示例
输入：
2 3 18
输出：
[[0, 6], [3, 4], [6, 2], [9, 0]]
4代码：
个人
num = input().split()
a = eval(num[0])
b = eval(num[1])
c = eval(num[2])
n = c//a
result = []
total = 0
for i in range(n+1):
for j in range((c-a*i)//b+1):
if(a*i+b*j==c):
result.append([i,j])
total = total +1
print(result)
print(total)答案
'''双向递推（双指针）利用该函数单调递增的特性
先固定 x ，从0 开始，那么可以让 y 从后往前找到匹配值
如果匹配到了以后，那么对应于这个 x 已经没用了，x 可以增加
同时增加后的 x 要匹配的 y 就一定比上一个 y 少。
这就是双指针法的思路。假定c是1000
一个 x 指向头(0)，一个 y 指向尾(1000)
判断 x 和 y 能否使得函数值等于 c
当这个函数值小了，就增加 x
当这个函数值大了，就减少 y
相等的时候添加到答案，同时 x 和 y 一起更新。
'''
a,b,c = map(int,input().split())
ls = []
x,y=0,c
while 1:
if a*x+b*y==c:
ls.append([x,y])
x+=1
y-=1
elif a*x+b*y>c:
y-=1
else:
x+=1
if x>c or y<0:
break
print(ls)
print(len(ls))
'''#遍历效率低
a,b,c = map(int,input().split())
ls = []
for x in range(c+1):
for y in range(c+1):
if a*x+b*y == c:
ls.append([x,y])
print(ls)
print(len(ls))
'''
2206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
