当前位置： 移动技术网 > IT编程>脚本编程>Python > 软工第五次作业——Python效能分析之四则运算生成器

软工第五次作业——Python效能分析之四则运算生成器

2018年04月19日  | 移动技术网IT编程  | 我要评论

淘伴网,同庆帝,雀神2呖咕呖咕对对碰

Github项目地址：

https://github.com/JtvDeemo/elementary-arithmetic

PSP

PSP2.1 Personal Software Process Stages 预估耗时（分钟） 实际耗时（分钟）
Planning 计划 10 10
· Estimate · 估计这个任务需要多少时间 1440 920
Development 开发 700 200
· Analysis · 需求分析 (包括学习新技术) 180 240
· Design Spec · 生成设计文档 5 5
· Design Review · 设计复审 (和同事审核设计文档) 10 15
· Coding Standard · 代码规范 (为目前的开发制定合适的规范) 5 5
· Design · 具体设计 40 60
· Coding · 具体编码 300 380
· Code Review · 代码复审 30 30
· Test · 测试（自我测试，修改代码，提交修改） 30 30
Reporting 报告 120 120
· Test Report · 测试报告+博客 120 120
· Size Measurement · 计算工作量 10 10
· Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划 40 50
合计 3040 2195

题目要求：

  • 能自动生成小学四则运算题目
  • 除了整数外，还要支持真分数的四则运算
    除了以上的基本需求，还有
  • 生成的算式长度随机
  • 能处理分数的运算，结果能用分数(字符串类型)表示出来，能与用户输入相对应

解题思路：

  • 定义一个函数用于随机生成随机长度的算式
  • 把字符串型的算式转换为逆波兰式(RPN，也称后缀表达式)
  • 再把后缀表达式利用栈结构计算出结果
  • 最后再与用户的输入做比较

重点难点：

  1. 分数的表示与计算
  2. 后缀表达式的生成和计算
  3. 结果为负数的情况

如何解决：

  1. Python的分数计算可以用 fractions 库
  2. https://blog.csdn.net/qq_36763635/article/details/72627601 这里介绍了如何将中缀表达式转换为后缀表达式（RPN）
  3. https://blog.csdn.net/yangquanhui1991/article/details/52187375 图解后缀表达式的计算过程
  4. 对于结果为负数的情况，只能生成算式之后验算一遍，若为负数的情况，重新生成一遍(可能是个人水平有限)

设计实现：

具体程序设计:

成员变量

成员名 类型 功能
op list 存放运算符
quest str 存放算式
lens int 2到9的随机长度
teop str 存放当前运算符
tstr str 存放当前算式
tint int 存放当前运算数

成员函数

函数名 输入 输出 依赖函数 功能
get_string 冇 字符串 冇 随机生成一个算式
get_ans str 返回布尔类型 get_string 将用户输入与正确答案比较
to_rpn str 返回后缀表达式 get_ans 将随机生成的算式转换为RPN
this_bigger str,str 返回布尔表达式 冇啊 比较两个运算符的优先级
slove_rpn str 返回计算结果 get_ans 将后缀表达式计算出来

核心代码：

#随机生成一个算式
    def get_string(self):
        self.lens = random.randint(2, 9)
        self.teop = ''
        self.tstr = []
        for i in range(self.lens):
            if self.teop == '÷':
                self.tint = random.randint(1, 8)
                self.teop = random.choice(self.op)
            elif self.teop == '/':
                self.tint = random.randint(self.tint+1, 9)
                self.teop = random.choice(self.op[:-1])
            else:
                self.tint = random.randint(0, 8)
                self.teop = random.choice(self.op)
            self.tstr.append(str(self.tint))
            self.tstr.append(self.teop)
        self.tstr[-1] = '='
        self.tstr = ''.join(self.tstr)
        self.quest = self.tstr
        return self.tstr
#将随机生成的算式转换为RPN
    def to_rpn(self, ques):  #Reverse Polish notation
        self.stack = []
        s = ''
        for x in ques:
            if x != '+' and x != '-' and x != '×' and x != '÷' and x != '/':
                s += x  #若为数字，直接输出
            else:  # 若为运算符，进栈
                if not self.stack:  #栈空
                    self.stack.append(x)
                else:
                    if self.this_bigger(x, self.stack[-1]):  #运算级高于栈顶元素
                        self.stack.append(x)  #直接进栈
                    else:
                        while self.stack:
                            if self.this_bigger(x, self.stack[-1]):
                                break
                            s += self.stack.pop()
                        self.stack.append(x)
        while self.stack:
            s += self.stack.pop()
        # print('在to_rpn函数中，rpn：',s)
        return s
#将后缀表达式计算出来
    def slove_rpn(self, rpn):
        #print('进入slove_rpn函数：')
        self.stack1 = []  #用于保存运算数
        for x in rpn:
            if x != '+' and x != '-' and x != '×' and x != '÷' and x != '/':
                self.stack1.append(int(x))
            elif x == '+':
                second = self.stack1.pop()
                first = self.stack1.pop()
                self.stack1.append(first + second)
            elif x == '-':
                second = self.stack1.pop()
                first = self.stack1.pop()
                self.stack1.append(first - second)
            elif x == '×':
                second = self.stack1.pop()
                first = self.stack1.pop()
                self.stack1.append(first * second)
            elif x == '÷':
                second = self.stack1.pop()
                first = self.stack1.pop()
                self.stack1.append(Fraction(first, second))
            elif x == '/':
                second = self.stack1.pop()
                first = self.stack1.pop()
                self.stack1.append(Fraction(first, second))
        resault = self.stack1[0]
        if resault >= 0:
            #print('--------------题结束----------------')
            return resault
        elif resault < 0:
            s = self.get_string()
            rpn = self.to_rpn(s[:-1])
            return self.slove_rpn(rpn)

运行效果：

单元测试

《构建之法》第二章中详细提及了好的单元测试的标准。

  • 单元测试应该在最基本的功能/参数上检验程序的正确性。
  • 单元测试必须由最熟悉代码的人来写。
  • 单元测试过后，机器状态保持不变。
  • 单元测试要快。
  • 单元测试应该产生可重复、一致的结果。
  • 独立性-单元测试的运行/通过/失败不依赖于别的测试，可以人为构造数据，以保持测试的独立性。
  • 单元测试应该覆盖所有代码路径。

效能分析图

Pycharm中运行profiler，次数为10W次

可以看到所用的时间长度为16.04s

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网