李光证 3117004660
吴子昊 3117004671
李光证博文地址：https://www.cnblogs.com/Gleez/p/11688368.html
一、
1. github项目地址：
https://github.com/amekao/SE_work2
2. 界面示例：
生成模式
批改模式
二、PSP表格
PSP2.1
Personal Software Process Stages
预估耗时(分钟)
实际耗时(分钟)
Planning
计划
· Estimate
· 估计这个任务需要多少时间
1200
1200
Development
开发
· Analysis
· 需求分析 (包括学习新技术)
180
200
· Design Spec
· 生成设计文档
20
30
· Design Review
· 设计复审 (和同事审核设计文档)
30
60
· Coding Standard
· 代码规范 (为目前的开发制定合适的规范)
30
30
· Design
· 具体设计
100
100
· Coding
· 具体编码
600
720
· Code Review
· 代码复审
200
180
· Test
· 测试(自我测试，修改代码，提交修改)
100
90
Reporting
报告
· Test Report
· 测试报告
30
40
· Size Measurement
· 计算工作量
10
10
· Postmortem & Process Improvement Plan
· 事后总结, 并提出过程改进计划
10
10
合计
1310
1470
三、效能分析
使用line_profiler模块对时间进行测试：
①重新写了一个time.py进行测试，对里面main函数修改，不使用argv来获取参数，而是直接在程序里面赋值
②在需要测试的模块前加上@profiler标志符
③使用 kernprof -l time.py运行程序，生成time.py.lprof报表
④使用 python -m line_profiler time.py.lprof 查看报表
生成模式：生成10000道范围在0到10的题目
生成模式核心代码：
#生成模式
ques_count = 10000max_val= 10random_exercises(ques_count, max_val)
核心模块random_exercises的用时：
Total time: 5.14441s
File: time.py
Function: random_exercises at line12Line#Hits Time Per Hit % Time Line Contents
==============================================================
12@profile13 defrandom_exercises(q_c, m_v):14 """15 根据输入的题目数量和数字范围，生成题目文件和答案文件
16 :param q_c: 题目数量
17 :param m_v: 数字最大值
18 :return: 在目录下生成试题文件和答案文件
19"""
20 1 1028.0 1028.0 0.0 e_open = open("Exercises.txt", "a+")21 1 1073.0 1073.0 0.0 a_open = open("Answers.txt", "a+")22 10001 14619.0 1.5 0.1 for i inrange(0, q_c):23 10000 7059101.0 705.9 56.3 post =question.post_order_generator(m_v)24 10000 217674.0 21.8 1.7 tree =question.post_to_tree(post)25 10000 178163.0 17.8 1.4 ordinary =question.tree_to_ordinary(tree, [])26 10000 2002280.0 200.2 16.0 readable_str =question.to_readable(ordinary)27 10000 109711.0 11.0 0.9 e_open.write(f'{i+1}、{readable_str}\n')28
29 10000 2428198.0 242.8 19.4 ans =question.count_ans(post)30 10000 423654.0 42.4 3.4 answer = question.to_with_fraction(ans) #转成带分数
31 10000 103062.0 10.3 0.8 a_open.write(f'{i+1}、{answer}\n')32 1 576.0 576.0 0.0e_open.close()33 1 390.0 390.0 0.0 a_open.close()
批改模式：对刚才生成的10000条题目的答案进行修改
批改模式核心代码：
#批改模式
exercise_path = "Exercises.txt"answer_path= "Answers.txt"make_standard(exercise_path)
check_exercise(answer_path)
模块make_standard的用时：
Total time: 1.72545s
File: time.py
Function: make_standard at line35Line#Hits Time Per Hit % Time Line Contents
==============================================================
35@profile36 defmake_standard(e_p):37 """38 根据题目文件生成标准答案StandardAnswers.txt
39 :param e_p: 题目文件的path
40 :return: 生成StandardAnswers.txt
41"""
42 1 9.0 9.0 0.0 try:43 1 409.0 409.0 0.0 e_open = open(e_p, "r")44 exceptFileNotFoundError:45 print("找不到该文件")46sys.exit()47 except:48 print("文件打开失败，请重新运行程序")49sys.exit()50 1 775.0 775.0 0.0 sa_open = open("StandardAnswers.txt", "a+")51 1 10663.0 10663.0 0.3 e_lines =e_open.readlines()52 10001 15022.0 1.5 0.4 for line ine_lines:53 10000 28078.0 2.8 0.7 ques_num = line.split("、")[0] #题目序号
54 10000 31358.0 3.1 0.7 ques_str = line.split("、")[1].rstrip('\n') #去掉前面的序号和后面换行符
55 10000 894383.0 89.4 21.3 ordinary =question.to_unreadable(ques_str)56 10000 370173.0 37.0 8.8 post =question.ordinary_to_post(ordinary)57 10000 2341848.0 234.2 55.7 sa =question.count_ans(post)58 10000 413446.0 41.3 9.8 standard =question.to_with_fraction(sa)59 10000 98687.0 9.9 2.3 sa_open.write(f'{ques_num}、{standard}\n')60
61 1 266.0 266.0 0.0e_open.close()62 1 673.0 673.0 0.0 sa_open.close()
模块check_exercises的用时：
Total time: 0.0277891s
File: time.py
Function: check_exercise at line64Line#Hits Time Per Hit % Time Line Contents
==============================================================
64@profile65 defcheck_exercise(a_p):66 """67 标准答案与用户答案逐行对比，统计对错
68 :param a_p: 用户答案path
69 :return: 生成Grade.txt统计文件
70"""
71 1 459.0 459.0 0.7 sa_open = open("StandardAnswers.txt", "r")72 1 264.0 264.0 0.4 a_open = open(a_p, "r")73 1 5800.0 5800.0 8.6 sa_lines =sa_open.readlines()74 1 3.0 3.0 0.0 right =[]75 1 1.0 1.0 0.0 wrong =[]76
77 10001 10571.0 1.1 15.6 for sa_line insa_lines:78 10000 20640.0 2.1 30.5 if sa_line ==a_open.readline():79 10000 20990.0 2.1 31.0 right.append(sa_line.split("、")[0])80 else:81 wrong.append(sa_line.split("、")[0])82 1 94.0 94.0 0.1sa_open.close()83 1 32.0 32.0 0.0a_open.close()84
85 1 5839.0 5839.0 8.6 grade_open = open("Grade.txt", "a+")86 1 3019.0 3019.0 4.5 grade_open.write(f'正确{len(right)}题：{right}\n')87 1 24.0 24.0 0.0 grade_open.write(f'错误{len(wrong)}题：{wrong}\n')
具体时间分析看第五部分后面
四、设计实现过程
简易版类图
question.py是与数学操作相关的函数，大部分由光证同学完成
main.py是主函数，负责获取用户输入并调用question里面函数，由子昊同学完成
程序有正向输出和逆向两部分模块
正向输出：逆波兰表达式列表 → 转化为二叉树 → 转化为中序表达式列表 → 转化为人看的字符串形式
逆向：人看的字符串形式 → 中序表达式列表 → 逆波兰表达式列表
逆波兰表达式的好处是不需要括号，减少程序复杂度，运算顺序完全取决于数字的排列，而且计算可以方便地通过入栈出栈来实现。
生成题目模式使用的random_exercises模块就是正向输出，先生成逆波兰表达式，使用count_ans函数进行计算，存入Answers.txt中，之后再正向输出字符串到Exercises.txt
批改题目模式使用make_standard模块：逆向把Exercises.txt的字符串转化为逆波兰表达式，使用count_ans函数进行计算，保存到StandardAnswers.txt
check_exercises模块：逐行与Answers.txt对比，正确的就存入right列表，错误的就存入wrong列表，最后输出各列表的元素和元素个数
五、核心代码讲解
1. 随机生成逆波兰表达式
1 defpost_order_generator(max_value):2 """
3 逆波兰式子生成器，随机生成一个逆波兰表达式4 :param max_value: int类型，表示数值的最大值5 :return: 存储逆波兰表达式的列表6 """
7 ch = ('+', '-', '×', '÷')8 char_num = random.randrange(1, 4)9 num_num = char_num - 1
10 #suffix_list是逆波兰表达式列表，先在列表前面插入两个数字
11 suffix_list =[str(get_random_fraction(max_value)), str(get_random_fraction(max_value))]12 now_num = 2
13 while char_num ornum_num:14 if now_num >= 2:15 if char_num and random.randrange(0, 2):16 suffix_list.append(ch[random.randrange(0, 4)])17 now_num = now_num - 1
18 char_num = char_num - 1
19 elifnum_num:20 suffix_list.append(str(get_random_fraction(max_value)))21 num_num = num_num - 1
22 now_num = now_num + 1
23 else:24 suffix_list.append(ch[random.randrange(0, 4)])25 char_num = char_num - 1
26 now_num = now_num - 1
27 else:28 suffix_list.append(str(get_random_fraction(max_value)))29 now_num = now_num + 1
30 num_num = num_num - 1
31 st = ".".join(suffix_list)32 if st in problem_set or count_ans(suffix_list) <0:33 suffix_list =post_order_generator(max_value)34 returnsuffix_list35 else:36 problem_set.add(st)37 return suffix_list
逆波兰表达式的限制是第一二个元素必须是数字，最后一个元素必须是运算符，另外数字个数是运算符个数+1
本模块是先随机出式子有n个运算符，则数字有n+1个，除去前两个数先放入列表，和列表最后的运算符，则剩下的符号数和数字数都是n-1，之后在剩下位置随机生成
另外将生成的逆波兰表达式转化为字符串存入一个set集合中，由于集合的唯一性，如果新生成的表达式已经在集合中，则这条式子要重新生成
遗憾的是3+4和4+3的判重我们还是没有成功实现
2. 逆波兰转二叉树
1 defpost_to_tree(post_list):2 """
3 把逆波兰式转换成一棵模拟二叉树4 :param post_list: 逆波兰式列表5 :return: 一个列表，表示一棵树6 """
7 ch = ('+', '-', '×', '÷')8 temp =[]9 for v inpost_list:10 if v inch:11 t1, t2 =temp.pop(), temp.pop()12 temp.append([t2, t1, v])13 else:14 temp.append(v)15 return temp[0]
逆波兰表达式的两个数字存入叶子结点，运算符存入根结点，成为一棵二叉树
3. 二叉树转中序表达式
1 deftree_to_ordinary(tree_list, medium_list):2 """
3 把二叉树转换成普通表达式4 :param tree_list: 二叉树的列表5 :param medium_list:中序表达式的列表，主要为了递归调用，刚开始可传一个空列表6 :return:一个普通表达式的列表7 """
8 ch_val = {'+': 1, '-': 1, '×': 2, '÷': 2} #符号优先级
9 if type(tree_list[0]) ==list:10 if ch_val[tree_list[2]] > ch_val[tree_list[0][2]]:11 medium_list.append('(')12 medium_list =tree_to_ordinary(tree_list[0], medium_list)13 medium_list.append(')')14 else:15 medium_list =tree_to_ordinary(tree_list[0], medium_list)16 else:17 medium_list.append(tree_list[0])18 medium_list.append(tree_list[2])19 if type(tree_list[1]) ==list:20 medium_list.append('(')21 medium_list = tree_to_ordinary(tree_list[1], medium_list)22 medium_list.append(')')23 else:24 medium_list.append(tree_list[1])25 return medium_list
对于这一棵二叉树，后序遍历就是逆波兰表达式(后缀表达式)，中序遍历就是中序表达式(平时用的样式)
难点在于× ÷号的优先级比+ -号要高，遇到这种情况需要加括号
4. 计算逆波兰表达式
1 defcount_ans(post_list):2 """
3 计算逆波兰式的结果和判断这条式子是否合法，4 如果中途出现负数或者除零都会返回-1，否则返回最终结果5 :param post_list: 逆波兰式的列表6 :return: Fraction类型的结果7 """
8 ch = ('+', '-', '×', '÷')9 stack =[]10 for v inpost_list:11 if v inch:12 t1, t2 =stack.pop(), stack.pop()13 try:14 if v == '+':15 t1 = t1 +t216 elif v == '-':17 t1 = t2 -t118 elif v == '×':19 t1 = t1 *t220 else:21 t1 = t2 /t122 if t1 <0:23 return -1
24 stack.append(t1)25 exceptZeroDivisionError:26 return -1
27 else:28 stack.append(Fraction(v))29 return stack[0]
使用逆波兰表达式的计算就是因为式子中没有括号所以容易写程序，
将逆波兰表达式列表当做栈来使用，
新建一个ch元祖存+ - x ÷四个运算符，然后对逆波兰式列表中元素逐个遍历，如果元素是运算符，则把运算符前两个元素出栈进行计算再入栈，直到栈中没有运算符为止
回看效能分析：
生成模式：
1. 可以看到随机生成逆波兰表达式post_order_generator是最耗费时间的，占了56%的时间，猜测是因为random函数比较耗时，而一条式子平均需要5次random
2. 第二耗时间的是计算逆波兰count_ans，因为每一个列表元素都要遍历一下看在不在ch元祖里面，而且要做乘除法
3. 第三耗时间的让人惊奇，居然是转成可阅读to_readable，可能是将假分数转化为带分数需要做除法
批改模式：
1. make_standard模块中第一耗时是计算函数count_ans，理由同上
2. make_standard模块中第二耗时是转成不可阅读to_unreadable，作为to_readable的反函数，理由也是因为需要做乘法通分把整数部分加回去分子中
3. check_exercises模块中最耗时是逐行对比部分，该部分是这个模块最核心的代码，而且因为需要字符串匹配，看两边字符串是否一样
六、测试用例
由于本程序的特殊性，运行一次就可以生成n条测试，极大方便我们判断对错，以下给出生成15条算式时的例子
Myapp.exe -n 15 -r 10
生成的Exercises.txt
1、4'1/2 - 2/5
2、3/4 × 1/2
3、2'2/3 ÷ 1/2 + 1
4、2 × 4'1/2 ÷ 1'2/5
5、2/3 - ( 1/7 - ( 0 × 1'1/7 ) )
6、5/9 ÷ 5
7、0 × 7/9
8、2 + 1'3/4
9、1'1/5 ÷ 1
10、7/9 ÷ 1
11、1 + 1'1/2 + 4
12、0 × 0 × 7/8
13、( 5/7 + 1'1/5 ) ÷ 1/4
14、4 × 3
15、1'1/7 × ( 0 + 1/3 )
生成的答案Answers.txt
1、4'1/10
2、3/8
3、6'1/3
4、6'3/7
5、11/21
6、1/9
7、08、3'3/4
9、1'1/5
10、7/9
11、6'1/2
12、013、7'23/35
14、12
15、8/21
对其中的2 3 5 7 11 13题故意改成错误答案，存为MyAnswers.txt
1、4'1/10
2、3/9
3、6'1/4
4、6'3/7
5、6、1/9
7、5
8、3'3/4
9、1'1/5
10、7/9
11、6
12、013、7'23/36
14、12
15、8/21
使用如下代码执行批改模式
Myapp.exe -e Exercises.txt -a MyAnswers.txt
生成的标准答案StandardAnswers.txt和原来的Answers.txt完全一致
1、4'1/10
2、3/8
3、6'1/3
4、6'3/7
5、11/21
6、1/9
7、08、3'3/4
9、1'1/5
10、7/9
11、6'1/2
12、013、7'23/35
14、12
15、8/21
批改结果Grade.txt也判断正确
正确9题：['1', '4', '6', '8', '9', '10', '12', '14', '15']
错误6题：['2', '3', '5', '7', '11', '13']
七、小结
1. 子昊对光证的
个人认为本次结对编程项目非常成功，大家都发挥了各自的所长，李光证同学是ACM队的，对算法比较熟悉，我因为在工作室做过项目，对使用python比较有经验
一开始我们讨论了两种方案，方案一是由内往外生成，即5 x(6 +(7 + 5))，从7+5开始生成，7+5和5+7等价，再到6+12和12+6等价，不过这样会引入很多无用的括号而且括号括的位置也千奇百怪;
因此后来选择了使用逆波兰表达式的方案，计算可以直接对列表出栈入栈，也省却了括号的麻烦，使用树即可把逆波兰表达式转为平常的中序表达式。
光证对算法方面比较熟悉，所以负责逆波兰表达式的生成，计算，转化，其他零散的部分则由我完成。
这次是光证先写出他的部分，(他花了大概5小时)再由我来组装，我在刚接手光证代码时，被一堆奇奇怪怪的数据结构方面的用法搞懵了，完全看不懂·，而且代码很乱，不符合PEP8规范，在Pycharm中全是波浪线看着很难受，所以花了一点时间教会了光证用pycharm的自动pep8，并使用‘’‘’‘’来注释函数功能，这样在悬停时就可以看到这个函数究竟是做什么的，不过光证的150多行代码还是花了一个多小时才完全看懂。
后来就是根据自己的理解把光证的函数封装好，用时大约6小时，程序就写完了，后面再用了约2个小时对框架进行优化，将模块分得更细，更容易维护。所以整个开发流程还是比较舒服的，比个人项目快了好多，表扬光证。
所以这次的成功合作，一是分工明确，光证负责数学函数，我负责封装; 二是接口定义好，相对比较独立; 三是我和光证python水平差不多，而且在同一个宿舍方便交流; 四是大家都很好完成了自己的任务，没有互相拖沓。
希望以后还有更多类似这样完美的合作。
2. 光证对子昊的
经过多天的努力，本次的结对编程项目完美结束，在这次的结对项目中，收益匪浅。
子昊在工作室里面做过项目，有过合作的经验，并且对python的使用有经验，而我是学校ACM集训队的一员，对于算法的设计、实现比较熟悉。所以我主要负责编写关于表达式的生成，转换还有计算和分数之间的转换等功能函数，而子昊负责把我写的函数整合在一起，对于输入输出的编写还有程序的性能分析。
因为我是参加ACM竞赛的，平时敲的变量名能有多短就写多短，所以这次写代码的时候也奇奇怪怪的，所以第一次给子昊的时候他很难理解，然后子昊就来给我讲了python代码的规范，还有教会了我使用pycharm的一些窍门，我改完之后就好了很多。这可能就像萧伯纳所说的那样“你有一个苹果，我有一个苹果，我们交换一下，一人还是只有一个苹果；你有一个思想，我有一个思想，我们交换一下，一人就有两个思想”。
而本次也有许多的不足之处，比如表达式重复的问题我只排除了后缀表达式相同的情况而已，还有的就是最后函数没有封装进类里面。
953
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
