码迷,mamicode.com
首页 > 其他好文 > 详细

三、软工结对项目:四则运算生成器

时间:2019-10-16 21:50:03      阅读:82      评论:0      收藏:0      [点我收藏+]

标签:美的   split   好处   rand   ESS   ima   des   sign   else   

一、

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 = 10000
    max_val = 10
    random_exercises(ques_count, max_val)

 

核心模块random_exercises的用时:

Total time: 5.14441 s
File: time.py
Function: random_exercises at line 12

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    12                                           @profile
    13                                           def random_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 in range(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.0      e_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.72545 s
File: time.py
Function: make_standard at line 35

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    35                                           @profile
    36                                           def make_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                                               except FileNotFoundError:
    45                                                   print("找不到该文件")
    46                                                   sys.exit()
    47                                               except:
    48                                                   print("文件打开失败,请重新运行程序")
    49                                                   sys.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 in e_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.0      e_open.close()
    62         1        673.0    673.0      0.0      sa_open.close()

 

模块check_exercises的用时:

Total time: 0.0277891 s
File: time.py
Function: check_exercise at line 64

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    64                                           @profile
    65                                           def check_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 in sa_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.1      sa_open.close()
    83         1         32.0     32.0      0.0      a_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 def post_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 or num_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             elif num_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         return suffix_list
35     else:
36         problem_set.add(st)
37         return suffix_list

 

逆波兰表达式的限制是第一二个元素必须是数字,最后一个元素必须是运算符,另外数字个数是运算符个数+1

本模块是先随机出式子有n个运算符,则数字有n+1个,除去前两个数先放入列表,和列表最后的运算符,则剩下的符号数和数字数都是n-1,之后在剩下位置随机生成

另外将生成的逆波兰表达式转化为字符串存入一个set集合中,由于集合的唯一性,如果新生成的表达式已经在集合中,则这条式子要重新生成

遗憾的是3+4和4+3的判重我们还是没有成功实现

 

2. 逆波兰转二叉树

 1 def post_to_tree(post_list):
 2     """
 3     把逆波兰式转换成一棵模拟二叉树
 4     :param post_list: 逆波兰式列表
 5     :return: 一个列表,表示一棵树
 6     """
 7     ch = (+, -, ×, ÷)
 8     temp = []
 9     for v in post_list:
10         if v in ch:
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 def tree_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 def count_ans(post_list):
 2     """
 3     计算逆波兰式的结果和判断这条式子是否合法,
 4     如果中途出现负数或者除零都会返回-1,否则返回最终结果
 5     :param post_list: 逆波兰式的列表
 6     :return: Fraction类型的结果
 7     """
 8     ch = (+, -, ×, ÷)
 9     stack = []
10     for v in post_list:
11         if v in ch:
12             t1, t2 = stack.pop(), stack.pop()
13             try:
14                 if v == +:
15                     t1 = t1 + t2
16                 elif v == -:
17                     t1 = t2 - t1
18                 elif v == ×:
19                     t1 = t1 * t2
20                 else:
21                     t1 = t2 / t1
22                 if t1 < 0:
23                     return -1
24                 stack.append(t1)
25             except ZeroDivisionError:
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、41/2 - 2/5
2、3/4 × 1/2
3、22/3 ÷ 1/2 + 1
4、2 × 41/2 ÷ 12/5
5、2/3 - ( 1/7 - ( 0 × 11/7 ) )
6、5/9 ÷ 5
7、0 × 7/9
8、2 + 13/4
9、11/5 ÷ 1
10、7/9 ÷ 1
11、1 + 11/2 + 4
12、0 × 0 × 7/8
13、( 5/7 + 11/5 ) ÷ 1/4
14、4 × 3
15、11/7 × ( 0 + 1/3 )

生成的答案Answers.txt

1、41/10
2、3/8
3、61/3
4、63/7
5、11/21
6、1/9
7、0
8、33/4
9、11/5
10、7/9
11、61/2
12、0
13、723/35
14、12
15、8/21

 

对其中的2 3 5 7 11 13题故意改成错误答案,存为MyAnswers.txt

1、41/10
2、3/9
3、61/4
4、63/7
56、1/9
7、5
8、33/4
9、11/5
10、7/9
11、6
12、0
13、723/36
14、12
15、8/21

使用如下代码执行批改模式

Myapp.exe -e Exercises.txt -a MyAnswers.txt

生成的标准答案StandardAnswers.txt和原来的Answers.txt完全一致

1、41/10
2、3/8
3、61/3
4、63/7
5、11/21
6、1/9
7、0
8、33/4
9、11/5
10、7/9
11、61/2
12、0
13、723/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水平差不多,而且在同一个宿舍方便交流; 四是大家都很好完成了自己的任务,没有互相拖沓。

       希望以后还有更多类似这样完美的合作。

 

三、软工结对项目:四则运算生成器

标签:美的   split   好处   rand   ESS   ima   des   sign   else   

原文地址:https://www.cnblogs.com/amekao/p/11663853.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!