精华内容
下载资源
问答
  • python 四则运算表达式

    2021-06-05 12:48:20
    习题二 接受用户输入的四则运算表达式,使用栈进行表达式求值。算术表达式是形如“1 - 2 + 3 * 4”这样的表达式。为简单计,不考虑括号。</p>
  • 利用python中字符串列表来存储四则表达式,新建一个列表,大小为运算符个数+运算数,然后循环遍历此列表,在偶数位置插入随机的运算数,在奇数位置插入随机的运算符。 括号的插入: 左括号的插入位置是从0到操作...

    一. 项目基本信息

    项目成员:梁华超、林贤杰

    项目仓库:Github

    二. PSP2.1表格

    PSP2.1Personal Software Process Stages预估耗时(分钟)实际耗时(分钟)
    Planning 计划 20 25
    · Estimate · 估计这个任务需要多少时间 20 25
    Development 开发 1200 1740
    · Analysis · 需求分析 (包括学习新技术) 40 55
    · Design Spec · 生成设计文档 40 41
    · Design Review · 设计复审 (和同事审核设计文档) 30 20
    · Coding Standard · 代码规范 (为目前的开发制定合适的规范) 30 31
    · Design · 具体设计 40 66
    · Coding · 具体编码 1100 1520
    · Code Review · 代码复审 40 41
    · Test · 测试(自我测试,修改代码,提交修改) 60 64
    Reporting 报告 70 100
    · Test Report · 测试报告 20 24
    · Size Measurement · 计算工作量 20 21
    · Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划 30 58
    合计   1390 1963

    三. 设计实现过程及代码说明

    项目文件结构如下:

    模块功能
    main.py 主函数
    answer.py 计算答案和校对答案
    exp_generate.py 表达式生成
    suffix_expression.py 将中缀表达式转成后缀表达式和求值

    1.分析与设计

    本设计涉及到的基本数据类型和表达式有栈,二叉树,逆波兰表达式(后缀表达式)

    表达式生成 :

    仔细分析表达式有如下特点:

    • 运算数的个数比运算符多一
    • 被除数不能为0
    • 两个操作数不需要加括号

    利用python中字符串列表来存储四则表达式,新建一个列表,大小为运算符个数+运算数,然后循环遍历此列表,在偶数位置插入随机的运算数,在奇数位置插入随机的运算符。

    括号的插入:

    左括号的插入位置是从0到操作数个数的一半之间的一个随机数,右边括号为左括号的位置+1到操作数个数的一半+1。

    计算答案:

    将中缀表达式转为后缀表达式,再进行求值

    生成的二叉树如下这样:

    2.具体实现

    (1) 表达式生成关键代码

    需要注意的是除号后面的运算符不能为0,如果生成的是0,即重新生成插入,直到生成不为0的运算符为止。

    while i < exp_num:
                random_num_operation = randint(1, config.max_num_of_oper)
                is_need_parenteses = randint(0,1)
                number_of_oprand = random_num_operation + 1 #操作数比操作符的数目多1
                exp = []
                for j in range(random_num_operation + number_of_oprand):
                    if j % 2 == 0:
                        #随机生成操作数
                        exp.append(self.generate_operand(randint(0,3), config.num_range))
                        if j > 1 and exp[j-1] == '÷' and exp[j] == '0':
                            while True:
                                exp[j-1] = self.generate_operation()
                                if exp [j-1] == '÷':
                                    continue
                                else:
                                    break
                    else:
                        #生成运算符
                        exp.append(self.generate_operation())
                
                #判断是否要括号
                if is_need_parenteses and number_of_oprand != 2:
                    expression = " ".join(self.generate_parentheses(exp, number_of_oprand))
                else:
                    expression = " ".join(exp)
                
                #判断是否有重复
                if self.is_repeat(exp_list, expression) or suffix_to_value(to_suffix(expression)) == False:
                    continue
                else:
                    exp_list.append(expression)
                    i = i + 1

    (2)插入括号代码逻辑

    如果生成的括号表达式形如 (1 + 2/3 + 3),则认为是没有意义的括号,需要重新插入。

    if exp:
                exp_length = len(exp)
                left_position = randint(0,int(num/2))
                right_position = randint(left_position+1, int(num/2)+1)
                mark = -1
                for i in range(exp_length):
                    if exp[i] in ['+', '-', 'x', '÷']:
                        expression.append(exp[i])
                    else:
                        mark += 1
                        if mark == left_position:
                            expression.append('(')
                            expression.append(exp[i])
                        elif mark == right_position:
                            expression.append(exp[i])
                            expression.append(')')
                        else:
                            expression.append(exp[i])
            #如果生成的括号表达式形如 (1 + 2/3 + 3) 则重新生成
            if expression[0] == '(' and expression[-1] ==')':
                expression = self.generate_parentheses(exp, number_of_oprand)
                return expression

    (3)中缀转后缀和求值

    中缀表达式转后缀表达式的逻辑:

    1. 初始化两个栈,分为运算符栈和后缀表达式栈,遍历表达式列表,如果遇到运算符:

      a. 如果运算符栈为空,则直接入栈

      b. 如果运算符栈不为空,则取出栈顶top元素

      • 如果栈顶top元素是左括号或者算术优先级高于栈顶top元素,那么就直接入栈

      • 否则就入栈后缀表达式栈

    2. 如果遇到左括号:

      • 左括号直接入运算符栈

    3. 如果遇到右括号:

      • 如果运算符栈不为空,那么直接出栈,添加到后缀表达式栈,直到遇到左括号

    4. 遇到运算数直接入后缀表达式栈

    suffix_stack = []  #后缀表达式结果
        ops_stack = []  #操作符栈
        infix = exp.split(' ')
        #print(infix)
        for item in infix:
            if item in ['+', '-', 'x', '÷']: #遇到运算符
                while len(ops_stack) >= 0:
                    if len(ops_stack) == 0:
                        ops_stack.append(item)
                        break
                    op = ops_stack.pop()
                    if op == '(' or ops_rule[item] > ops_rule[op]:
                        ops_stack.append(op)
                        ops_stack.append(item)
                        break
                    else:
                        suffix_stack.append(op)
            elif item == '(': # 左括号直接入栈
                ops_stack.append(item)
            elif item == ')': #右括号
                while len(ops_stack) > 0:
                    op = ops_stack.pop()
                    if op == "(":
                        break
                    else:
                        suffix_stack.append(op)
            else:
                suffix_stack.append(item) # 数值直接入栈
        
        while len(ops_stack) > 0:
            suffix_stack.append(ops_stack.pop())

    四. 运行测试

    文件说明:

    文件说明
    Answer.txt 生成表达式答案文件
    Exercises.txt 生成表达式存储的文件
    Grade.txt 题目对错数量统计文件

     

    结果:

    效能分析:

    • 因为涉及到二叉树递归等操作,所以会有很多时间和空间的开销
    • IO读写也影响运算的时间

    五. 项目总结

    这次结对编程中,我和林贤杰一起深入分析项目的需求分析,找到实现需求的具体思路,设计具体实现的过程,我负责编码,林贤杰同学在旁边观察协助。在此过程中,我们也遇到了一些问题,也找到了解决的思路。总之,在结对编程中有很大的收获,实现1+1 > 2 。

    转载于:https://www.cnblogs.com/tworld/p/9709610.html

    展开全文
  • 利用栈实现四则运算表达式求值,附Python代码

    千次阅读 多人点赞 2018-08-13 20:52:39
    平时用到的标准的四则运算表达式就叫做中缀表达式,例如“9 +(3 - 1) * 3 + 10 / 2)”,特点是运算符在数字中间; 后缀表达式就是一种把运算符放在数字后面的形式,“9 3 1 - 3 * + 10 2 / +”即为上例中缀表达式...

    中缀表达式和后缀表达式

    平时用到的标准的四则运算表达式就叫做中缀表达式,例如“9 +(3 - 1) * 3 + 10 / 2)”,特点是运算符在数字中间;

    后缀表达式就是一种把运算符放在数字后面的形式,“9 3 1 - 3 * + 10 2 / +”即为上例中缀表达式对应的后缀表达式形式,后缀表达式还有一个特点就是消除了所有的括号;

    中缀表达式能够非常直观地展示出运算关系,很方便手动计算,但是如果要设计一个计算机程序来计算这个表达式却变得非常繁琐,不仅要考虑四则运算的优先级,还要考虑括号的影响,而后缀表达式虽然在表现形式上不直观却非常便于计算机进行计算。

    后缀表达式计算结果

    后缀表达式的计算要借助栈来实现。

    规则:从左到右遍历表达式的每个数字和符号,遇到的是数字就进栈,遇到的时符号就将栈顶的两个数字出栈进行计算,然后将计算结果入栈,最终栈里的值即为计算的结果。

    以中缀表达式“9 +(3 - 1) * 3 + 10 / 2)”的后缀表达式“9 3 1 - 3 * + 10 2 / +”为例,计算过程如下:

    1、初始化一个空栈

    2、后缀表达式前三个都是数字,所以9、3、1依次入栈,此时栈内元素为(最左边为栈底元素):9 3 1

    3、接下来为减号“-”,此时1出栈作为第二个数,3出栈作为第一个数(因为栈内元素是先进后出,所以最先出栈的为运算中的第二个数,接着出栈的才是运算中的第一个数),进行进行减法运算3 - 1 = 2然后入栈,此时栈内元素为:9 2

    4、接下来为数字3,进栈,栈内元素为:9 2 3

    5、接下来为乘号“*”,此时3、2出栈,进行乘法运算2 * 3 = 6,结果入栈,此时栈内元素为:9 6

    6、接下来是加号“+”,9、6出栈进行加法运算,结果15入栈,此时栈内元素为:15

    7、接下来是数字10、2入栈,此时栈内元素为:15 10 2

    8、接下来是除号“/”,10、2出栈进行除法运算,结果5入栈,此时栈内元素为:15 5

    9、最后一个是加号“+”,15、5出栈进行加法运算,结果20即为整个表达式的运算结果,与中缀表达式计算结果一致

    只需要按顺序遍历就能够计算出结果,不用考虑对四则运算法则做复杂的逻辑处理,对计算机处理来说是非常方便的,这样一来,最重要的问题就是怎样将中缀表达式转化为后缀表达式。

    中缀表达式转化为后缀表达式

    中缀表达式转化为后缀表达式同样要借助栈来实现,不同于中缀表达式的计算,这里的栈用于存贮运算符号而不是数值。

    规则:从左到右遍历中缀表达式中的每个数字和符号,若是数字就输出,即成为后缀表达式的一部分;若是符号则要分为两种情况:

    1)是括号时,如果是左括号,直接将左括号入栈,如果是右括号则栈顶元素依次出栈并输出,直到有一个左括号出栈(出栈的左括号不输出到后缀表达式)。

    2)是运算符号时,如果栈顶符号为左括号,则直接将这个运算符号入栈。栈顶符号不为左括号时,如果该运算符号优先级比栈顶运算符号高则入栈,比栈顶符号低或者相等时则栈顶元素依次出栈并输出直到栈为空或者栈顶为左括号为止,然后将这个符号入栈。

    最后将栈顶符号依次出栈并输出,得到的结果即为最终的后缀表达式。

    同样以中缀表达式“9 +(3 - 1) * 3 + 10 / 2)”为例推导其后缀表达式的步骤如下:

    1、初始化一个空栈

    2、第一个数字9直接输出到后缀表达式,第二个符号“+”入栈,此时后缀表达式:9    栈内符号:+

    3、接下里左括号入栈,数字3输出,此时后缀表达式为: 9 3    栈内元素为:+ (

    4、接下来是减号“-”,由于栈顶为左括号,直接入栈,数字1输出,此时后缀表达式:9 3 1    栈内符号:+ ( -

    5、接下来是右括号,栈顶符号“-”出栈并输出,接着栈顶左括号出栈,此时后缀表达式:9 3 1 -   栈内符号:+

    6、接下来是乘号“*”,比栈顶符号加号“+”优先级高,入栈,数字3输出,此时后缀表达式:9 3 1 - 3    栈内符号:+ *

    7、接下来是加号“+”,比栈顶“*”优先级低,栈顶“*”出栈并输出,接着与新的栈顶加号“+”比较优先级相同,栈顶“+”出栈并输出,栈为空,到此为止,然后将加号“+”入栈。此时后缀表达式为:9 3 1 - 3 * +    栈内符号:+

    8、接下来数字10输出,除号“/”优先级比栈顶加号“+”优先级高直接入栈,此时后缀表达式:9 3 1 - 3 * + 10   栈内为:+ /

    9、最后数字2输出,遍历结束后,栈顶符号依次出栈并输出,得到最终的后缀表达式:9 3 1 - 3 * + 10 2 / +

    优化与整合

    通过前面的介绍,只需要经过将中缀表达式转化为后缀表达式,再计算后缀表达式这两步就能得到一个四则运算表达式的值。这两步中各用到了一个栈,推导后缀表达式时用到的栈存储的是运算符号以及括号(只有左括号,没有右括号),计算后缀表达式时用到的栈存储的是数字,两个步骤分开先后执行要遍历一次中缀表达式载遍历一遍后缀表达式。同时在中缀表达式推导后缀表达式以及计算后缀表达式的过程中,都是要对字符串进行操作,如果将两步合并同时执行的话,不仅能够简化代码,更能提高运算效率,因为这样全程只需要遍历一次中缀表达式就可以完成计算。

    思路:用一个栈data保存运算数字,一个栈opt保存运算符号。从左到右遍历中缀表达式,如果是数字就入栈data,如果是符号,以下四种情况直接将符号入栈opt:1)栈为空;2)栈顶为左括号;3)该符号为左括号;4)该运算符号优先级比栈顶符号高。如果是右括号,则执行一次计算步骤:从opt出栈一个运算符号,从data出栈两个数字进行一次运算并将结果入栈data。重复执行该计算步骤,直到opt栈顶为左括号,然后将该左括号出栈;如果该符号优先级低于opt栈顶符号或者与栈顶符号优先级相同时,重复执行与之前相同的计算步骤,直到opt栈为空,若中途opt栈顶符号为左括号则停止执行计算步骤。中缀表达式遍历完成后,继续执行之前的计算步骤直到opt栈为空。

    因为Python处理字符串比较简洁方便,代码使用Python3编写,为输入方便起见,其中输入的表达式字符串中不包含空格,代码中忽略了对输入表达式不合法的处理,假设输入表达式是可以正确计算的:

    def compare(op1, op2):
        """
        比较两个运算符的优先级,乘除运算优先级比加减高
        op1优先级比op2高返回True,否则返回False
        """
        return op1 in ["*", "/"] and op2 in ["+", "-"]
    
    
    def getvalue(num1, num2, operator):
        """
        根据运算符号operator计算结果并返回
        """
        if operator == "+":
            return num1 + num2
        elif operator == "-":
            return num1 - num2
        elif operator == "*":
            return num1 * num2
        else:  # /
            return num1 / num2
    
    
    def process(data, opt):
        """
        opt出栈一个运算符,data出栈两个数值,进行一次计算,并将结果入栈data
        """
        operator = opt.pop()
        num2 = data.pop()
        num1 = data.pop()
        data.append(getvalue(num1, num2, operator))
    
    
    def calculate(s):
        """
        计算字符串表达式的值,字符串中不包含空格
        """
        data = []  # 数据栈
        opt = []  # 操作符栈
        i = 0  # 表达式遍历索引
        while i < len(s):
            if s[i].isdigit():  # 数字,入栈data
                start = i  # 数字字符开始位置
                while i + 1 < len(s) and s[i + 1].isdigit():
                    i += 1
                data.append(int(s[start: i + 1]))  # i为最后一个数字字符的位置
            elif s[i] == ")":  # 右括号,opt出栈同时data出栈并计算,计算结果入栈data,直到opt出栈一个左括号
                while opt[-1] != "(":
                    process(data, opt)
                opt.pop()  # 出栈"("
            elif not opt or opt[-1] == "(":  # 操作符栈为空,或者操作符栈顶为左括号,操作符直接入栈opt
                opt.append(s[i])
            elif s[i] == "(" or compare(s[i], opt[-1]):  # 当前操作符为左括号或者比栈顶操作符优先级高,操作符直接入栈opt
                opt.append(s[i])
            else:  # 优先级不比栈顶操作符高时,opt出栈同时data出栈并计算,计算结果如栈data
                while opt and not compare(s[i], opt[-1]):
                    if opt[-1] == "(":  # 若遇到左括号,停止计算
                        break
                    process(data, opt)
                opt.append(s[i])
            i += 1  # 遍历索引后移
        while opt:
            process(data, opt)
        print(data.pop())
    
    
    if __name__ == '__main__':
        exp = "(9+((3-1)*3+10/2))*2"
        calculate(exp)

     

    展开全文
  • Python生成四则运算表达式并且通过Django做了一个在线的集算数题目生成和在线答题、用户历史记录管理等为一体的网站

    四则运算题目生成器

    软件工程大作业的结对项目2–四则运算题目生成器

    这篇文章详述了问题定义、可行性研究和需求分析部分

    所需要的链接如下:
    SoftwareEngineering -Repositpory -GitHub
    QuestGeneratorWebsite -Repository -GitHub
    队友的博客链接 -CSDN

    1.前言:为啥要做这个项目

    问题定义

    这个问题乍一眼看上去比较简单,要求还是很清晰的,首先需要能够生成不重复的四则运算表达式,其次要能对四则运算表达式求值,接下来可以通过不同的途径实现不同的功能,可以构建一个具有UI界面的应用程序,或者搭一个用户输入参数可以生成题目的网站,也可以用一门新的语言制作动画将整个流程描述出来

    总而言之需要我们做一个生成题目–给出题目答案–对用户输入进行对错判断
    然后给刚才的题目生成器完善的要求

    可行性研究

    接下来说一下为什么认为这个题目可行

    选这个题目是因为对四则运算有基本的了解,因为有数据结构和离散数学的知识基础,离散数学曾经编写过一个程序就是去掉四则运算表达式当中的括号的,所以还是对这个课题比较有信心,而且这个项目的第三阶段里第二个方向正好与我当前所选的一门选修课一致
    ,而且Python代码比较简洁,正好可以锻炼一下自己所学语言的能力,也能熟悉如何利用Django后台如何搭建一个网站,所以最后我们选择了这个题目

    环境呢,我用的Mac电脑,搭配Pycharm 18.1 和Python3.7 加上Django 2.27,Pycharm在编写Django程序的时候比VS Code的优势还是很明显的

    PSP表格

    PSP2.1 Personal Software Process Stages 预估耗时(min) 实际耗时(min)
    Planning 计划 20 20
    Estimate 预估完成任务耗时 2900 2600
    Development 开发 - -
    Analysis 需求分析 200 150
    Design Spec 生成设计文档 60 40
    Design Review 复核文档 30 40
    Coding Standard 代码设计规范 10 50
    Design 具体设计 50 30
    Coding 具体编码 2200 1800
    Code Review 代码复审 150 120
    Test 测试 120 300
    Reporting 报告
    Test Report 测试报告 50 20
    Size Measurement 计算工作量 30 20
    Postmortem& Process Improvement Plan 事后总结与改进计划 90 30
    合计 2900 2600

    项目分工

    我主要负责代码的编码,项目设计部分,也负责一部分的单元测试内容
    队友主要负责代码评审(使用pylint)和一部分的测试内容
    在项目的设计初期,我们将工程分为了两个部分,第一部分是运算表达式生成和运算,其中包括生成四种类型的运算表达式,判断用户输入结果是否相等,把所有的结果保存到一个txt文件中等
    第二部分是写一个网络应用程序,可以保存用户信息并且给用户生成题目,也可由用户指定参数生成题目

    需求分析

    在分析了结对项目要求文档后,我们认为这个项目由以下功能需求构成:

    功能需求

    功能需求我们分为了四个阶段,分别对应了开发过程的四个阶段所要实现的不同的功能

    第一阶段

    a)生成四则运算表达式
    b)实现可以运算的表达式求值功能
    c)添加乘方运算

    第二阶段

    a)添加分数运算功能
    b)对无法运算的表达式重新生成(/0或结果过大过小,乘方的幂次解出的是一个无法除尽的不循环小数)
    c)接受用户输入并且生成特定题目
    d)将生成的题目保存
    e)接受用户输入并且判断对错

    第三阶段

    a)创建一个网页应用程序
    b)将前两阶段实现的内容以包的形式集成到后端
    c)创建数据库实现题目、用户管理
    d)实现用户信息管理功能(登录注册修改密码)
    e)实现用户输入参数获得相应题目的功能

    第四阶段

    a)在网页端实现接受用户输入判断对错功能
    b)实现对用户输入题目的对错进行记录的功能
    c)实现输出用户做过的错题历史的功能

    性能需求

    我们希望生成题目的速度尽可能快,最好能够在30s时间内完成1000道题目的生成和保存操作,网页端希望网页端的并发能力尽可能强,使用非阻塞式的方式与客户端进行通信,并且希望数据库的安全性尽可能高,保证并发操作的成功率

    其他需求

    由于这是给小学生生成题目,我们希望可以对不同年级的小学生控制出题的不同难度,可以实现有针对性的出题

    前两阶段的设计和编码

    前两阶段的设计和编码

    网站部分

    网站部分包括概要设计和详细设计,编码和测试,性能分析的内容

    第三阶段

    网页部分-第三阶段(1)
    网页部分-第三阶段(2)
    网页部分-第三阶段(3)

    第四阶段

    网页部分-第四阶段(1)

    测试和性能分析

    测试和性能分析列为单独的博客,因为内容比较独立,但是又很关键

    代码测试
    性能分析和代码审查

    事后总结和提升

    事后总结和提升

    概述

    剩下的主要是所搭网站的前端后端部分

    所使用的架构是Django架构,同样是python写的开源服务器架构

    Django版本2.27 没有使用最新的3.0版本因为3.0版本当中据说有未修复的bug

    对于先前已经实现的功能,引入只需要将源码打包在一个文件夹里,就可以在后端轻松引入

    网页效果概览

    a)首先就是希望网页端可以实现用户输入参数从题库中随机生成题目的功能,这个功能因为有数据库的辅助实现起来还是比较简单的;

    b) 其次就是希望可以做到用户管理,用户可以注册可以登录如果忘记密码可以通过预留的邮箱找回密码,这个功能也是可以实现的;

    c) 第三个就是希望可以像第三阶段的第一个要求让用户在线答题,并且由于有用户管理的准备工作可以生成用户答题的历史记录,并且记录错题信息

    网站MVC部分

    网页部分是严格按照MVC设计模式实现的,所以在此介绍一下MVC模型

    模型

    Django中的模型是在每一个app中的models构成的,通过在models中建立class就相当于在数据库中建立了一张表,这些表由Django维护,对于这些表的调用一般是在Views中进行

    视图

    Django中的视图是每一个app中的views文件中的函数,view和model的引用是通过import models中的class实现的,通过这种方法可以轻松的实现对数据的增删改查

    控制器

    Django的控制器是用的urls文件,通过对urls.py的配置将用户请求映射到处理函数,urls.py文件存在于项目的根文件和app文件中,通过对url的匹配规则的修改调用不同apps中的不同视图函数实现对用户输入的控制并且向模型发送数据

    项目的开发流程

    以下是项目的完整开发过程

    Software_engineering部分:

    12.12

    进行了问题定义、可行性研究、需求分析和概要设计工作,生成了用例图模型,对功能需求划分为四个阶段进行开发,对第一阶段的代码进行了部分功能实现

    12.14

    进行详细设计工作,生成了类图、顺序图模型

    对第一部分代码的另外功能不断实现,并且对代码进行了部分精化,完成了第一部分的编码工作

    加入了求解器类,实现了基本运算

    12.15

    对求解器类进行了编码,增加了分数运算功能,对Origin类进行了部分精化,修正了可能造成歧义的代码,实现了常规的四舍五入方法

    增加了分数运算功能入口,增加了对乘方运算的限制,可以进行基本的分数乘方运算

    运算结果改为全部以分数表达,方便后续运算过程,改了一部分代码格式

    12.16

    增加了求解器功能,可以对用户的输入进行对错判断

    1.3

    加入了单元测试部分的代码,修正了单元测试中发现的四舍五入方法的问题

    1.4

    使用单元测试代码对算数模块进行测试

    1.5

    对生成器模块进行了单元测试

    1.6

    增加了solve和getOperOrder的测试用例,对单元测试代码进行了补充

    1.9

    增加了solve模块的单元测试用例,对之前的部分单元测试代码进行了补充

    1.14

    对代码进行了重构,提升了代码质量

    1.15

    对代码进行了检查,改了部分不规范的大小写,去掉了多余的空行,保证了代码风格统一

    1.16

    增加了OriginRequest的一个模块方法,增加了模块之间的独立性

    远程服务器进行了merge

    对模块中的参数进行了重新命名,避免命名规则的冲突

    对代码进行性能测试,去掉了运行时间较长的部分,对运行时间不合理的位置进行了检查或者代码修改

    增加测试用例

    1.17

    增加了新的测试用例,删除了不需要的文件,单元测试覆盖率达到100%

    QuestGeneratorWebsite部分

    12.16

    进行了概要设计和详细设计,生成了功能模型、静态模型(类图)和动态模型(顺序图)
    进行了初步的编码工作

    12.17

    数据库已经生成了初始数据
    实现数据库可以直接通过quest的unique属性判重
    有了找回密码功能
    有了开题工具的功能
    把sousousou的接口接入了QuestGeneratorWebsite

    12.18

    修改了Cascade的数据库集联错误
    有了题目生成功能,从数据库中取出的数据filter后用output_list保存
    更改部分网页名称和URL规则

    12.19

    增加了History数据库模型,还没有加入History功能和在线答题功能
    加了出题功能,还差后端验证,后端验证对应上了题目和作答
    修改了部分错误
    修改了部分URL规则

    12.20

    增加了验证题目功能,并且将错误题目成功保存进了数据库
    增加了防止重复提交表单刷分的功能,修改了score字段没有存到数据库中的bug
    完善了三种出题功能

    12.21

    对前端进行精化,修改了一部分没有来得及更改的前端信息
    加入了查看历史记录的功能,前端填充了对应历史记录的链接

    1.2

    根据SoftwareEngineering中出现的错误,对generate部分进行了重新编写
    修改网页中存在的部分bug

    1.14

    对代码进行重构,生成了新的用例图和顺序图模型

    1.15

    增加了单元测试的测试用例,提升了代码的完整性和可靠性,对代码的编码风格进行了统一

    展开全文
  • 软件工程项目 四则运算表达式生成(python实现) 部分app的后端 软件工程项目 四则运算表达式生成----3 模板部分 设置按钮的样式,鼠标放上和点击前后的变化 <style> /* 按钮边框的大小、位置、样式 */ ...

    四则运算题目生成器

    软件工程大作业的结对项目–四则运算题目生成器

    这是第三阶段的网页部分(前端)的原理和功能

    需求分析部分链接如下
    软件工程项目 四则运算表达式生成----3

    后端的编写过程如下,贴上队友的链接
    软件工程–四则运算表达式(4)

    使用了bootstrap,版本是3.37,也使用了JQuery3.31的库,提升网页美观程度

    base.html

    前端有base基页面,提供通用的模板,还有每一个app里面自带的页面,用 block拓展base.html来动态渲染

    {% load staticfiles %}
    <!DOCTYPE html>
    <html lang="zh-CN">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <!-- 上述3个meta标签*必须*放在最前面,任何其他内容都*必须*跟随其后! -->
        <title>{% block title %}{% endblock %}</title>
        <link href="{% static 'bootstrap-3.3.7-dist/css/bootstrap.min.css' %}" rel="stylesheet">
        {% block css %}{% endblock %}
    <body>
    {% block navbar %}{% endblock %}
    <div id="wrapper">
        <div class="content-body">
                        {% block content %}
                        {% endblock content %}
                    {% block sidemenu %}
                    {% endblock %}
                </div>
        <div id="push"></div>
    </div>
    {% include 'footer.html' %}
    <script src="{% static 'js/jquery-3.3.1.js' %}"></script>
    <script src="{% static 'bootstrap-3.3.7-dist/js/bootstrap.min.js' %}"></script>
    <script src="{% static 'layer/layer.js' %}"></script>
    {% block script %}{% endblock script %}
    {% include 'top.html' %}
    <style>
        html, body {
            height: 100%;
            margin: 0;
        }
    
        #wrapper {
            min-height: 100%;
            margin-bottom: -60px;
        }
    
        #push {
            height: 60px;
        }
    </style>
    </body>
    </html>
    

    引入了navbar,content和sidebar的块,style是设置页脚的样式。

    模板部分

    设置按钮的样式,鼠标放上和点击前后的变化

    <style>
        /* 按钮边框的大小、位置、样式 */
        .toTop-arrow {
            width: 3.5rem;
            height: 3.5rem;
            padding: 0;
            margin: 0;
            border: 0;
            border-radius: 33%;
            opacity: 0.7;
            background: aliceblue;
            cursor: pointer;
            position: fixed;
            right: 1.5rem;
            bottom: 1.5rem;
            display: none;
        }
        .toTop-arrow::before, .toTop-arrow::after {
            width: 31px;
            height: 7px;
            border-radius: 3px;
            background: orange;
            position: absolute;
            content: "";
        }
        .toTop-arrow::before {
            -webkit-transform: rotate(-50deg) translate(0, -50%);
            left: 0.4rem;
        }
        .toTop-arrow::after {
            -webkit-transform: rotate(50deg) translate(0, -50%);
            right: 0.4rem;
        }
        /* 取消点击按钮时的聚焦 */
        .toTop-arrow:focus {
            outline: none;
        }
    </style>
    
    login的模板
    {% extends 'base.html' %}
    {% load staticfiles %}
    {% block title %}登录{% endblock %}
    {% block navbar %}
        <nav class="navbar navbar-default">
            <div class="container-fluid">
                <!-- Brand and toggle get grouped for better mobile display -->
                <div class="navbar-header">
                    <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                            aria-expanded="false">
                        <span class="sr-only">切换导航条</span>
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                    </button>
                    <a class="navbar-brand" href="{% url 'SouSouSou:main' %}">猿题库</a>
                </div>
                <!-- Collect the nav links, forms, and other content for toggling -->
                <div class="collapse navbar-collapse" id="my-nav">
                    <ul class="nav navbar-nav">
                        <li class="active"><a href="{% url 'SouSouSou:main' %}">主页</a></li>
                        <li class="align-baseline"><a href="{% url 'SouSouSou:main' %}">小猿搜题</a></li>
                    </ul>
                    <form class="navbar-form navbar-left">
                        <div class="form-group">
                            <input type="text" class="form-control" placeholder="Search">
                        </div>
                        <button type="submit" class="btn btn-default">快搜搜</button>
                    </form>
                    <ul class="nav navbar-nav navbar-right">
                        <li><a href="/login/">登录</a></li>
                        <li><a href="/register/">注册</a></li>
                    </ul>
                </div>
            </div>
        </nav>
    {% endblock %}
    {% block css %}
        <link href="{% static 'css/login.css' %}" rel="stylesheet"/>{% endblock %}
    
    {% block content %}
        <div class="container">
            <div class="col-12" align="center">
                <br>
                <h2>还没有账号?</h2>
                <h3>点击<a href='/register'>注册账号</a>加入我们吧!</h3>
                <br>
            </div>
            <div class="col-md-4 col-md-offset-4">
                <form class='form-login' action="/login/" method="post">
    
                    {% if message %}
                        <div class="alert alert-warning">{{ message }}</div>
                    {% endif %}
                    {% csrf_token %}
                    <h2 class="text-center">欢迎登录</h2>
                    <div class="form-group">
                        {{ login_form.username.label_tag }}
                        {{ login_form.username }}
                    </div>
                    <div class="form-group">
                        {{ login_form.password.label_tag }}
                        {{ login_form.password }}
                    </div>
                    <button type="reset" class="btn btn-default pull-left">重置</button>
                    <button type="submit" class="btn btn-primary pull-right">提交</button>
                <br><br>
                  <h5>忘记密码了?点击<a href='{% url 'reset_password:confirm' %}'>这里</a>重置密码</h5>
                </form>
            </div>
        </div> <!-- /container -->
    {% endblock %}
    

    navbar是渲染了导航条部分。用户可以选择直接登录,没有注册的用户选择注册。

    register的模板
    {% extends 'base.html' %}
    {% block title %}注册{% endblock %}
    {% block content %}
        <div class="container">
            <div class="col-md-4 col-md-offset-4">
              <form class='form-register' action="/register/" method="post">
     
                  {% if message %}
                      <div class="alert alert-warning">{{ message }}</div>
                  {% endif %}
     
                  {% csrf_token %}
     
                  <h2 class="text-center">欢迎注册</h2>
                  <div class="form-group">
                      {{ register_form.username.label_tag }}
                      {{ register_form.username}}
                  </div>
                  <div class="form-group">
                      {{ register_form.password1.label_tag }}
                      {{ register_form.password1 }}
                  </div>
                  <div class="form-group">
                      {{ register_form.password2.label_tag }}
                      {{ register_form.password2 }}
                  </div>
                  <div class="form-group">
                      {{ register_form.email.label_tag }}
                      {{ register_form.email }}
                  </div>
                  <div class="form-group">
                      {{ register_form.sex.label_tag }}
                      {{ register_form.sex }}
                  </div>
                  <div class="form-group">
    
                      {{ register_form.captcha.label_tag }}
                      {{ register_form.captcha }}
                  </div>
                  <button type="reset" class="btn btn-default pull-left">重置</button>
                  <button type="submit" class="btn btn-primary pull-right">提交</button>
              </form>
            </div>
        </div> <!-- /container -->
    {% endblock %}
    

    navbar部分和前面是一样的,这里写的是content部分,整个是一个容器,其中是一个注册表单,表单数据被发送到/register/,请求方式是post。接下来是一个居中文本:欢迎注册,下面表单对应form中的表单类,调用bootstrap模板,不知道具体原理是什么。都是由一个标签文本和一个输入框组成。包括captcha验证码模块。最后是重置和提交的按钮,用来清空输入框和提交表单,分别置左和置右

    主界面的模板
    {% block content %}
        <div class="container">
            <div class="row">
                <div class="col-12">
                    <br>
                    <a href="{% url 'Quest_Generator:Generator' %}">
                        <h3>出题考考自己?</h3>
                    </a>
                    <a href="{% url 'SouSouSou:Generator' %}">
                        <h3>给儿子儿媳出出题?</h3>
                    </a>
                </div>
            </div>
        </div>
    {% endblock %}
    

    有出题和做题的超链接,用url的匹配规则调用,跳转到相应页面

    Sousousou的模板
    {% block content %}
        <div class="container">
            <div class="row">
                <div class="col-12">
                    <br>
                    {% if type == "GET" %}
                        <form method="POST" action=".">
                            {% csrf_token %}
                            <div class="form-group">
                                {{ form.quantity.label_tag }}
                                {{ form.quantity }}
                            </div>
                            <div class="form-group">
                                <label for="operators">{{ form.operators.label_tag }}</label>
                                <select class="form-control col-lg-9" id="operators" name="operators" multiple="multiple"
                                        required="required">
                                    <option value="2">小学生都笑了的难度2</option>
                                    <option value="3">小学生都笑了的难度3</option>
                                    <option value="4">小学生都笑了的难度4</option>
                                    <option value="5">小学生皱起了眉头的难度5</option>
                                    <option value="6">小学生皱起了眉头的难度6</option>
                                    <option value="7">小学生皱起了眉头的难度7</option>
                                    <option value="8">小学生都哭了的难度8</option>
                                    <option value="9">小学生都哭了的难度9</option>
                                </select>
                            </div>
                            <div class="form-group">
                                {{ form.if_pow.label_tag }}
                                {{ form.if_pow }}
                            </div>
                            <div class="form-group">
                                {{ form.if_fra.label_tag }}
                                {{ form.if_fra }}
                            </div>
                            <div class="form-group">
                                {{ form.if_neg.label_tag }}
                                {{ form.if_neg }}
                            </div>
                            <div class="form-group">
                                {{ form.pow_type.label_tag }}
                                {{ form.pow_type }}
                            </div>
                            <button type="submit" class="btn btn-primary">完成</button>
                        </form>
                    {% elif type == "POST" %}
                        {% for out in output_list %}
                            <div class="entry-meta">
                                <span class="name"><a href="#">乘方 {{ out.question_if_pow }}</a></span>
                                <span class="name"><a href="#">负数 {{ out.question_if_negative }}</a></span>
                                <span class="name"><a href="#">操作符数 {{ out.question_operators_num }}</a></span>
                            </div>
                            {% if if_fraction == "True" %}
                                <h3>{{ out.question }} = {{ out.answer_Fraction }}</h3>
                            {% else %}
                                <h3>{{ out.question }} = {{ out.answer_float }}</h3>
                            {% endif %}
                        {% endfor %}
                    {% endif %}
                </div>
            </div>
        </div>
    {% endblock %}
    

    用户选择题量,难度,是否要乘方,是否要分数,是否要负数,乘方的符号。难度的选项组合在一起,设置成required必选,multiple表示能够多选。后面是submit类型的按钮,用于提交表单

    question的模板
    选择题目参数的部分
    {% block content %}
        <div class="container">
            <div class="row">
                <div class="col-12">
                    <br>
                    <form method="POST" action=".">
                        {% csrf_token %}
                        <div class="form-group">
                            {{ form.quantity.label_tag }}
                            {{ form.quantity }}
                        </div>
                        <div class="form-group">
                            <label for="operators">{{ form.operators.label_tag }}</label>
                            <select class="form-control col-lg-9" id="operators" name="operators" multiple="multiple"
                                    required="required">
                                <option value="2">小学生都笑了的难度2</option>
                                <option value="3">小学生都笑了的难度3</option>
                                <option value="4">小学生都笑了的难度4</option>
                                <option value="5">小学生皱起了眉头的难度5</option>
                                <option value="6">小学生皱起了眉头的难度6</option>
                                <option value="7">小学生皱起了眉头的难度7</option>
                                <option value="8">小学生都哭了的难度8</option>
                                <option value="9">小学生都哭了的难度9</option>
                            </select>
                        </div>
                        <div class="form-group">
                            {{ form.if_pow.label_tag }}
                            {{ form.if_pow }}
                        </div>
                        <div class="form-group">
                            {{ form.if_fra.label_tag }}
                            {{ form.if_fra }}
                        </div>
                        <div class="form-group">
                            {{ form.if_neg.label_tag }}
                            {{ form.if_neg }}
                        </div>
                        <div class="form-group">
                            {{ form.pow_type.label_tag }}
                            {{ form.pow_type }}
                        </div>
                        <button type="submit" class="btn btn-primary">完成</button>
                    </form>
                </div>
            </div>
        </div>
    {% endblock %}
    

    选择题目参数的部分,用户填写表单,其中有题目数量,运算符数量,是否要乘方,是否要分数,是否要负数,乘方的符号,用submit类型的按钮提交

    答题的部分
    {% block content %}
        <div class="container">
            <div class="row">
                <div class="col-12">
                    {% if quantity == '5' %}
                        <form method="POST" action="{% url 'Quest_Generator:Answer' 5 answer_id %}">
                            {% csrf_token %}
                            <h5>{{ output_list.0.question }} = {{ form.Kt1 }}</h5>
                            <h5>{{ output_list.1.question }} = {{ form.Kt2 }}</h5>
                            <h5>{{ output_list.2.question }} = {{ form.Kt3 }}</h5>
                            <h5>{{ output_list.3.question }} = {{ form.Kt4 }}</h5>
                            <h5>{{ output_list.4.question }} = {{ form.Kt5 }}</h5>
                            <button type="submit" class="btn btn-primary">完成</button>
                        </form>
                    {% endif %}
                    {% if quantity == '10' %}
                        <form method="POST" action="{% url 'Quest_Generator:Answer' 10 answer_id %}">
                            {% csrf_token %}
                            <h5>{{ output_list.0.question }} = {{ form.Kt1 }}</h5>
                            <h5>{{ output_list.1.question }} = {{ form.Kt2 }}</h5>
                            <h5>{{ output_list.2.question }} = {{ form.Kt3 }}</h5>
                            <h5>{{ output_list.3.question }} = {{ form.Kt4 }}</h5>
                            <h5>{{ output_list.4.question }} = {{ form.Kt5 }}</h5>
                            <h5>{{ output_list.5.question }} = {{ form.Kt6 }}</h5>
                            <h5>{{ output_list.6.question }} = {{ form.Kt7 }}</h5>
                            <h5>{{ output_list.7.question }} = {{ form.Kt8 }}</h5>
                            <h5>{{ output_list.8.question }} = {{ form.Kt9 }}</h5>
                            <h5>{{ output_list.9.question }} = {{ form.Kt10 }}</h5>
                            <button type="submit" class="btn btn-primary">完成</button>
                        </form>
                    {% endif %}
                    {% if quantity == '20' %}
                        <form method="POST" action="{% url 'Quest_Generator:Answer' 20 answer_id %}">
                            <h5>{{ output_list.0.question }} = {{ form.Kt1 }}</h5>
                            <h5>{{ output_list.1.question }} = {{ form.Kt2 }}</h5>
                            <h5>{{ output_list.2.question }} = {{ form.Kt3 }}</h5>
                            <h5>{{ output_list.3.question }} = {{ form.Kt4 }}</h5>
                            <h5>{{ output_list.4.question }} = {{ form.Kt5 }}</h5>
                            <h5>{{ output_list.5.question }} = {{ form.Kt6 }}</h5>
                            <h5>{{ output_list.6.question }} = {{ form.Kt7 }}</h5>
                            <h5>{{ output_list.7.question }} = {{ form.Kt8 }}</h5>
                            <h5>{{ output_list.8.question }} = {{ form.Kt9 }}</h5>
                            <h5>{{ output_list.9.question }} = {{ form.Kt10 }}</h5>
                            <h5>{{ output_list.10.question }} = {{ form.Kt11 }}</h5>
                            <h5>{{ output_list.11.question }} = {{ form.Kt12 }}</h5>
                            <h5>{{ output_list.12.question }} = {{ form.Kt13 }}</h5>
                            <h5>{{ output_list.13.question }} = {{ form.Kt14 }}</h5>
                            <h5>{{ output_list.14.question }} = {{ form.Kt15 }}</h5>
                            <h5>{{ output_list.15.question }} = {{ form.Kt16 }}</h5>
                            <h5>{{ output_list.16.question }} = {{ form.Kt17 }}</h5>
                            <h5>{{ output_list.17.question }} = {{ form.Kt18 }}</h5>
                            <h5>{{ output_list.18.question }} = {{ form.Kt19 }}</h5>
                            <h5>{{ output_list.19.question }} = {{ form.Kt20 }}</h5>
                            <button type="submit" class="btn btn-primary">完成</button>
                        </form>
                    {% endif %}
                </div>
            </div>
        </div>
    {% endblock %}
    

    用户填写表单来答题,此时请求方式是post,答完后通过url匹配跳转到answer的页面

    显示分数和用时的部分
    {% block content %}
        <div class="container">
            <div class="row">
                <div class="col-12">
                    <h3>你的用时{{ time }}</h3>
                    <h3>你的分数{{ score }}</h3>
                    {% for outs in output_list %}
                        {% if if_fra %}
                            <h4>你错的题{{ outs.question }} 的答案应该是 {{ outs.answer_Fraction }}</h4>
                        {% else %}
                            <h4>你错的题{{ outs.question }} 的答案应该是 {{ outs.answer_float }}</h4>
                        {% endif %}
                    {% endfor %}
                </div>
            </div>
        </div>
    {% endblock %}
    

    如果选择的是分数,显示分数答案,如果是小数,显示小数答案

    页面部分

    登录后的主界面

    在这里插入图片描述
    分为两个部分,一个是用户选择题目数量,并选择题目参数,系统从数据库中提出相应个数的题,返回给用户,另一个是用户向出题个数的表单中填写参数,系统返回题目和答案

    搜题部分

    用户选择题量,系统返回题目,用户答题在这里插入图片描述

    出题部分

    用户填写题量表单,系统返回题目和答案
    在这里插入图片描述

    展开全文
  • 四则运算题目生成器 ...软件工程–四则运算表达式 第三阶段:网站部分 概述 剩下的主要是所搭网站的前端后端部分 所使用的架构是Django架构,同样是python写的开源服务器架构 Django版本2.27 没...
  • 四则运算题目生成器 ...软件工程项目 四则运算表达式生成(python实现) login部分 login的表单 其中有登录和注册两个表单类 from django import forms from captcha.fields import CaptchaFie...
  • print("%.2f" % eval(input())) 转载于:https://www.cnblogs.com/MapReduce/p/8370788.html
  • /usr/bin/env python # -*- coding:utf-8 -*- # Filename:test_expr.py import unittest from expr import * class ExprTestCase(unittest.TestCase): def setUp(self): return de
  • 【转】https://blog.csdn.net/xyh1re/article/details/81634236
  • Python四则运算

    2020-11-23 10:27:30
    Python四则运算 思路:输入一串表达式,比如20✳35=,然后运算出结果20✳35= 700 缺点:只能进行一次运算,如果输入连加连乘,就报错。后续使用正则表达式进行过滤,应该可以实现。 #-*- coding: utf-8 -*- def add...
  • 四则运算题目生成器 这将是这次软件工程项目的最后一篇博客,这个项目经过了一个多月的紧张开发终于接近尾声,通过这个项目我收获了什么,又学到了什么,我希望在这篇博客中总结一下,也就是作为事后总结与提升了 ...
  • PHP给定值通过四则运算,求运算表达式 https://blog.csdn.net/luochuan/article/details/7258907 针对原有算法进行了优化如下: 1、原文只显示一个表达式,现在显示所有; 2、显示所有会出现重复,增加重复过滤; 3...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 文章目录栈的特点一、中缀表达式转化为后缀表达式二、后缀表达式计算1.遍历表达式2.计算方法完整代码 栈的特点 栈是限定仅在表尾进行插入和删除操作的线性表。允许插入与删除的一段叫做栈顶,另一端叫做栈底,不含...
  • 用正则表达式实现四则运算表达式解析器 思路: 根据计算优先级,先计算内部括号里面的运算,并用计算结果的字符串形式替换原表达式,直到没有括号运算符; 然后匹配乘法和除法的运算因子,按从左往右的顺序依次更.....
  • python练习作业...importmath,re string="1.5-2.4*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))" string=''.join(string.split())#字符串去空格 #字符串格式化 defs...
  • python 代码实现四则运算 (前缀表达式)   计算表达式如下: (+ 1 2 ) (+ 1 (+ 2 3)) (* (+ 1 2) (*3 4))   第一个函数cal_1 是使用递归的形式; 第二个函数cal_2 是使用非递归的形式--堆栈, 且第二个支持...
  • 平时用到的标准的四则运算表达式就叫做中缀表达式,例如“9 +(3 - 1) * 3 + 10 / 2)”,特点是运算符在数字中间; 后缀表达式就是一种把运算符放在数字后面的形式,“9 3 1 - 3 * + 10 2 / +”即为上例中缀表达式...
  • 使用Python实现的四则运算,注释清晰,功能备注完整,主要练习函数递归和正则表达式,目前只能计算整数的四则运算,如需完善,可把int改为float类型,然后修改正则表达式即可,代码逻辑完全不用动。供初学Python的...
  • 相信大家在学习数据结构时,就学习了简单四则运算表达式求解的一个算法,可惜一直没有自己动手实现过这个算法。最近重拾数据结构与算法,恰巧又正在用Python比较频繁,所幸就用它来实现这个算法,虽然网上有很多代码...
  • python 栈-解析四则运算公式

    万次阅读 2020-07-13 21:09:02
    文章目录python 栈-解析四则运算公式1、栈栈的抽象数据类型解析算数表达式中序转后序后序表达式计算2、解析四则运算-Coding 1、栈 栈也被称为下堆栈, 他是有序集合, 添加操作和移除操作发生在同一端,即顶端, 另...
  • python 二叉树-解析四则运算公式

    万次阅读 2020-07-13 21:12:39
    文章目录python 二叉树-解析四则运算公式1、解析树完全括号表达式2、解析四则运算-Coding 1、解析树 根据括号构建解析数 计算解析树中的表达式 将解析树还原为最初的数学表达式 构建表达式 **((7+3)*(8-6))**的...
  • # 是符号的话需要判断栈内的符号优先级,将高于等于当前优先级的符号输出,然后当前符号进栈 res.extend(priority_exp(i, stack)) while not stack.empty(): res.append(stack.pop()) return " ".join(res) # 四则运算 ...
  • 给你一个简单的四则运算表达式,包含两个实数和一个运算符,请编程计算出结果 输入 表达式的格式为:s1 op s2, s1和s2是两个实数,op表示的是运算符(+,-,*,/),也可能是其他字符 输出 如果运算符合法,输出表达式的...
  • 四则运算表达式必定包含运算数,还可能包含运算符和括号( ),不含空格等其它字符 运算数必定包含数字,还可能包含正或负符号+、-以及小数点. 运算符仅有+(加)、-(减)、(乘以)、/(除以)四种 括号可以嵌套 ...
  • 四则运算 python

    2019-08-07 22:12:17
    中缀表达式9+3*(2+1)转为后缀表达式思路9+3*(2+1): ...第个元素为运算符“ * ”,由于 “ * ” 的优先级大于栈顶元素 +,所以将其加入到运算符栈中:+ *; 第五个元素为“ ( ”,加入到运算符栈中:+ *...
  • 给你一个简单的四则运算表达式,包含两个实数和一个运算符,请编程计算出结果 输入 表达式的格式为:s1 op s2, s1和s2是两个实数,op表示的是运算符(+,-,*,/),也可能是其他字符 输出 如果运算符合法,输出表达式的...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 147
精华内容 58
关键字:

python四则运算表达式

python 订阅