python计算器

思路：
优先级处理
思路一：正则表达式+递归（计算时间慢）
思路二：堆栈的方式

队列：先进先出
电梯--》队列
上电梯（入队123）：第三个人3，第二个人2，第一个人1
>>> li = []
>>> li.insert(0,'p1')#进队列
>>> li.insert(0,'p2')
>>> li.insert(0,'p3')
>>> li
['p3', 'p2', 'p1']
或者用append('元素')
下电梯（出队123）：第一个人，第二个人，第三个人
>>> li.pop()#出队列
'p1'
>>> li.pop()
'p2'
>>> li.pop()
'p3'
>>>
如果用append方法，就用li.pop(0)
堆栈：先进后出
衣服箱子--》堆栈
装衣服（入栈123）：第三件衣服3，第二件衣服2，第一件衣服1
>>> li = []
>>> li.insert(0,'a1')#进栈
>>> li.insert(0,'a2')
>>> li.insert(0,'a3')
>>> li
['a3', 'a2', 'a1']
>>>

取衣服（出栈321）：第三件衣服，第二件衣服，第一件衣服
>>> li.pop(0)#出栈
'a3'
>>> li.pop(0)
'a2'
>>> li.pop(0)
'a1'
>>>

数字栈
运算符栈
拼接成表达式运算

实例：

#!/usr/bin/env python

#_*_coding:utf-8_*_

import re

#判断是数字还是符号的函数

def is_symbo(element):#遍历元素

    res = False#判断运算符

    symbol=['+','-','*','/','(',')']

    if element in symbol:

        res=True

    return res

#exp优先级比较

def priority(top_sym,wait_sym):

    #print('from the priotry:',top_sym,wait_sym)

    level1=['+','-']

    level2=['*','/']

    level3 = ['(']

    level4 = [')']

    #运算符栈栈顶元素为+-

    if top_sym in level1:

        # if wait_sym in level1:

        #     return '>'

        # elif wait_sym in level2:#top_sym='-' wait_sym='*'

        #     return '<'

        # elif wait_sym in level3:#top_sym='-' wait_sym='('

        #     return '<'

        # elif wait_sym in level4:#top_sym='-' wait_sym=')'

        #     return '>'

        # else:

        #     return '>'

        #优化

        if wait_sym in level2 or wait_sym in level3:

            return '<'

        else:

            return '>'

    # 运算符栈栈顶元素为*/

    elif top_sym in level2:

        # if wait_sym in level1:#top_sym='*' wait_sym='+'

        #     return '>'

        # if wait_sym in level2:#top_sym='*' wait_sym='*'

        #     return '>'

        # elif top_sym in level3:#top_sym='-' wait_sym='('

        #     return '<'

        # elif top_sym in level4:#top_sym='-' wait_sym=')'

        #     return '>'

        # else:

        #     return '>'

        #优化

        if wait_sym in level3:

            return '<'

        else:

            return '>'

    #运算符栈顶元素为（

    elif top_sym in level3:

        if wait_sym in level4:#右括号)碰到了(，那么左括号应该弹出栈

            return '='

        else:

            return '<'#只要栈顶顶元素为（，等待入栈的元素都应该无条件入栈

    # 运算符栈顶元素为)

#用来计算的,执行计算结果

def calculate(num1,symbol,num2):

    res=0

    if symbol == '+':

        res=num1+num2

    elif symbol =='-':

        res=num1-num2

    elif symbol =='*':

        res=num1*num2

    elif symbol =='/':

        res=num1/num2

    print('from calculate res is [%s|%s|%s] %s' %(num1,symbol,num2,res))

    return res

#接受一个表达式

def init_action(expression):

    #print(expression)

    #去掉空格，匹配空格，替换为空，目标是expression，重新赋值给expression

    expression = re.sub(' ','',expression)

    #print(expression)

    init_l = [i for i in re.split('(\-\d+\.*\d*)',expression)if i]#提取-数字

    #print('--->',init_l)

    expression_l=[]#格式化列表，初始化为空

    while True:

        if len(init_l) ==0:break#pop完了结束

        exp=init_l.pop(0)#列表左侧弹元素

        #print('==>',exp)#打印列表每个元素

        if len(expression_l) ==0 and re.search('^\-\d+\.*\d*$',exp):#-开头，数字结尾，匹配负数

            expression_l.append(exp)

            continue#直接进行下次循环，不分割-1

        #判断负数出现的情况

        if len(expression_l) > 0:

            if re.search('[\+\-\*\/\(]$',expression_l[-1]):

                expression_l.append(exp)

                continue#不做切分，-2这步

        new_l = [i for i in re.split('([\+\-\*\/\(\)])',exp) if i]#切分结果

        #print(new_l)

        expression_l+=new_l

        #print(expression_l)

    return expression_l

#主函数

def main(expression_l):

    #print('from in the main',expression_l)

    number_stack=[]#数字栈

    symbol_stack=[]#运算符栈

    for ele in expression_l:#遍历元素是数字还是运算符

        print('-' * 20)

        print('数字栈', number_stack)

        print('运算符栈', symbol_stack)

        print('待入栈运算符', ele)

        ret = is_symbo(ele)

        #print(ret)

        if not ret:

            #压入数字栈

            ele=float(ele)

            number_stack.append(ele)

        else:

            # 压入运算符栈

            while True:

                if len(symbol_stack) == 0:

                    symbol_stack.append(ele)

                    break

                res=priority(symbol_stack[-1],ele)#优先级比较

                if res == '<':

                    symbol_stack.append(ele)

                    break

                elif res == '=':#右括号碰到左括号的情况

                    symbol_stack.pop()

                    break

                elif res == '>':

                    symbol = symbol_stack.pop()

                    num2=number_stack.pop()

                    num1=number_stack.pop()

                    number_stack.append(calculate(num1,symbol,num2))

    else:

        symbol = symbol_stack.pop()

        num2 = number_stack.pop()

        num1 = number_stack.pop()

        number_stack.append(calculate(num1, symbol, num2))

    return number_stack,symbol_stack

if __name__ == '__main__':

    #用户输入表达式

    expression = '-1 - 2 *((-60+30+(-40/5)*(-9-2*-5/30-7/3*99/4*2998+10/-568/14))-(-4*-3)/(16-3*2))+3'

    # expression='(1-2*3)-1-2*((-60+30+(-40/5)*(-9-2*-5/30-7/3*99/4*2998+10*568/14))-(-4*-3)/(16-3*2))+3'

    #expression='-1 -3*( -2+3)'

    #格式化处理，得到一个列表

    expression_l = init_action(expression)#把用户输入的表达式格式化成一个列表的形式

    #print(expression_l)

    #分到数字栈，运算符栈

    #主函数，处理格式化后的列表

    jieguo=main(expression_l)#数字栈

    print('最终结果是:%s' % jieguo[0][0])

结果：

--------------------

数字栈 []

运算符栈 []

待入栈运算符 -1

--------------------

数字栈 [-1.0]

运算符栈 []

待入栈运算符 -

--------------------

数字栈 [-1.0]

运算符栈 ['-']

待入栈运算符 2

--------------------

数字栈 [-1.0, 2.0]

运算符栈 ['-']

待入栈运算符 *

--------------------

数字栈 [-1.0, 2.0]

运算符栈 ['-', '*']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0]

运算符栈 ['-', '*', '(']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0]

运算符栈 ['-', '*', '(', '(']

待入栈运算符 -60

--------------------

数字栈 [-1.0, 2.0, -60.0]

运算符栈 ['-', '*', '(', '(']

待入栈运算符 +

--------------------

数字栈 [-1.0, 2.0, -60.0]

运算符栈 ['-', '*', '(', '(', '+']

待入栈运算符 30

--------------------

数字栈 [-1.0, 2.0, -60.0, 30.0]

运算符栈 ['-', '*', '(', '(', '+']

待入栈运算符 +

from calculate res is [-60.0|+|30.0] -30.0

--------------------

数字栈 [-1.0, 2.0, -30.0]

运算符栈 ['-', '*', '(', '(', '+']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0, -30.0]

运算符栈 ['-', '*', '(', '(', '+', '(']

待入栈运算符 -40

--------------------

数字栈 [-1.0, 2.0, -30.0, -40.0]

运算符栈 ['-', '*', '(', '(', '+', '(']

待入栈运算符 /

--------------------

数字栈 [-1.0, 2.0, -30.0, -40.0]

运算符栈 ['-', '*', '(', '(', '+', '(', '/']

待入栈运算符 5

--------------------

数字栈 [-1.0, 2.0, -30.0, -40.0, 5.0]

运算符栈 ['-', '*', '(', '(', '+', '(', '/']

待入栈运算符 )

from calculate res is [-40.0|/|5.0] -8.0

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0]

运算符栈 ['-', '*', '(', '(', '+']

待入栈运算符 *

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0]

运算符栈 ['-', '*', '(', '(', '+', '*']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(']

待入栈运算符 -9

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(']

待入栈运算符 -

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-']

待入栈运算符 2

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0, 2.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-']

待入栈运算符 *

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0, 2.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 -5

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0, 2.0, -5.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 /

from calculate res is [2.0|*|-5.0] -10.0

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0, -10.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 30

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -9.0, -10.0, 30.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 -

from calculate res is [-10.0|/|30.0] -0.3333333333333333

from calculate res is [-9.0|-|-0.3333333333333333] -8.666666666666666

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-']

待入栈运算符 7

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 7.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-']

待入栈运算符 /

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 7.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 3

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 7.0, 3.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 *

from calculate res is [7.0|/|3.0] 2.3333333333333335

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 2.3333333333333335]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 99

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 2.3333333333333335, 99.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 /

from calculate res is [2.3333333333333335|*|99.0] 231.00000000000003

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 231.00000000000003]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 4

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 231.00000000000003, 4.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '/']

待入栈运算符 *

from calculate res is [231.00000000000003|/|4.0] 57.75000000000001

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 57.75000000000001]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 2998

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -8.666666666666666, 57.75000000000001, 2998.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '-', '*']

待入栈运算符 +

from calculate res is [57.75000000000001|*|2998.0] 173134.50000000003

from calculate res is [-8.666666666666666|-|173134.50000000003] -173143.1666666667

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+']

待入栈运算符 10

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667, 10.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+']

待入栈运算符 /

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667, 10.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+', '/']

待入栈运算符 -568

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667, 10.0, -568.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+', '/']

待入栈运算符 /

from calculate res is [10.0|/|-568.0] -0.017605633802816902

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667, -0.017605633802816902]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+', '/']

待入栈运算符 14

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.1666666667, -0.017605633802816902, 14.0]

运算符栈 ['-', '*', '(', '(', '+', '*', '(', '+', '/']

待入栈运算符 )

from calculate res is [-0.017605633802816902|/|14.0] -0.0012575452716297787

from calculate res is [-173143.1666666667|+|-0.0012575452716297787] -173143.16792421197

--------------------

数字栈 [-1.0, 2.0, -30.0, -8.0, -173143.16792421197]

运算符栈 ['-', '*', '(', '(', '+', '*']

待入栈运算符 )

from calculate res is [-8.0|*|-173143.16792421197] 1385145.3433936958

from calculate res is [-30.0|+|1385145.3433936958] 1385115.3433936958

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958]

运算符栈 ['-', '*', '(']

待入栈运算符 -

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958]

运算符栈 ['-', '*', '(', '-']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958]

运算符栈 ['-', '*', '(', '-', '(']

待入栈运算符 -4

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, -4.0]

运算符栈 ['-', '*', '(', '-', '(']

待入栈运算符 *

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, -4.0]

运算符栈 ['-', '*', '(', '-', '(', '*']

待入栈运算符 -3

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, -4.0, -3.0]

运算符栈 ['-', '*', '(', '-', '(', '*']

待入栈运算符 )

from calculate res is [-4.0|*|-3.0] 12.0

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0]

运算符栈 ['-', '*', '(', '-']

待入栈运算符 /

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0]

运算符栈 ['-', '*', '(', '-', '/']

待入栈运算符 (

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0]

运算符栈 ['-', '*', '(', '-', '/', '(']

待入栈运算符 16

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 16.0]

运算符栈 ['-', '*', '(', '-', '/', '(']

待入栈运算符 -

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 16.0]

运算符栈 ['-', '*', '(', '-', '/', '(', '-']

待入栈运算符 3

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 16.0, 3.0]

运算符栈 ['-', '*', '(', '-', '/', '(', '-']

待入栈运算符 *

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 16.0, 3.0]

运算符栈 ['-', '*', '(', '-', '/', '(', '-', '*']

待入栈运算符 2

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 16.0, 3.0, 2.0]

运算符栈 ['-', '*', '(', '-', '/', '(', '-', '*']

待入栈运算符 )

from calculate res is [3.0|*|2.0] 6.0

from calculate res is [16.0|-|6.0] 10.0

--------------------

数字栈 [-1.0, 2.0, 1385115.3433936958, 12.0, 10.0]

运算符栈 ['-', '*', '(', '-', '/']

待入栈运算符 )

from calculate res is [12.0|/|10.0] 1.2

from calculate res is [1385115.3433936958|-|1.2] 1385114.1433936958

--------------------

数字栈 [-1.0, 2.0, 1385114.1433936958]

运算符栈 ['-', '*']

待入栈运算符 +

from calculate res is [2.0|*|1385114.1433936958] 2770228.2867873916

from calculate res is [-1.0|-|2770228.2867873916] -2770229.2867873916

--------------------

数字栈 [-2770229.2867873916]

运算符栈 ['+']

待入栈运算符 3

from calculate res is [-2770229.2867873916|+|3.0] -2770226.2867873916

最终结果是:-2770226.2867873916

python计算器的更多相关文章

python 计算器的（正则匹配+递归）
经过2天的长时间的战斗,python计算器终于完成了. import re val="1-2*((60-30*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3 ...
Python计算器实操
要求: 开发一个简单的python计算器实现加减乘除及拓号优先级解析用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * ...
7_python之路之python计算器
7_python之路之python计算器 1.程序说明:Readme.cmd 1.程序文件及说明: calculator.py 2.python版本:python-3.5.3 3.程序使用:pytho ...
作业1开发一个简单的python计算器
开发一个简单的python计算器实现加减乘除及拓号优先级解析用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568 ...
老男孩python作业5-开发一个简单的python计算器
开发一个简单的python计算器实现加减乘除及拓号优先级解析用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568 ...
project1_calculator（使用tkinter实现python计算器，含有具体过程与注释）
最终的运行效果图(程序见序号7): #!/usr/bin/env python# -*- coding:utf-8 -*-# ------------------------------------- ...
Github Python计算器开源项目二次开发--增加函数图形
先上原项目链接:https://github.com/xhf79/Calculator_pyqt python+Qt 开发的计算器原项目界面和功能如图所示: 科学计算的内容基本都有,但按照项目的提示 ...
开发一个简单的python计算器
要求: 实现加减乘除及拓号优先级解析用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4* ...
初版python计算器
作业: 使用正则表达式实现计算器功能. 实现: 1.实现带括号的计算 2.实现指数.加减乘除求余等功能先看运行结果: 请输入您的计算式: 1 - 2 * ( (60-30 +(-40.0/5) * ...

随机推荐

干货!表达式树解析"框架"(3)
最新设计请移步轻量级表达式树解析框架Faller http://www.cnblogs.com/blqw/p/Faller.html 这应该是年前最后一篇了,接下来的时间就要陪陪老婆孩子了关于表达 ...
vmware 安装xp 流水账
1. 分区 PQ分区.1个区,C盘,NTFS. 2. 安装XP 进入ghost,不要选择一键. 然后fromImage, d:\xxx\GHO
[ASP.NET MVC 小牛之路]03 - Razor语法
本人博客已转移至:http://www.exblr.com/liam Razor是MVC3中才有的新的视图引擎.我们知道,在ASP.NET中,ASPX的视图引擎依靠<%和%>来调用C#指 ...
salesforce 零基础学习（四十九）自定义列表分页之使用Pagination实现分页效果 ※※※
上篇内容为Pagination基类的封装,此篇接上篇内容描述如何调用Pagination基类. 首先先创建一个sObject,起名Company info,此object字段信息如下: 为了国际化考虑 ...
Java易混淆的概率：成员变量、类变量、实例变量、局部变量
先看代码 public class Variable{ int b=0; //实例变量 static int a=0; //类变量 final String c="wws"; // ...
深入理解javascript作用域系列第五篇——一张图理解执行环境和作用域
× 目录 [1]图示 [2]概念 [3]说明[4]总结前面的话对于执行环境(execution context)和作用域(scope)并不容易区分,甚至很多人认为它们就是一回事,只是高程和犀牛书关 ...
【开源】OSharp框架解说系列（4）：架构分层及IoC
OSharp是什么? OSharp是个快速开发框架,但不是一个大而全的包罗万象的框架,严格的说,OSharp中什么都没有实现.与其他大而全的框架最大的不同点,就是OSharp只做抽象封装,不做实现.依 ...
Web API接口之Geolocation
0.关于Geolocation Geolocation,地理位置API.用于获取用户的位置信息.它不算是现有的HTML5标准的“直系”成员,但是是W3C的一个标准.它几乎就是一个真正的JavaScri ...
MongoDB学习系列(2)--使用PHP访问MongoDB
第一部分:介绍在Windows上安装最新MongoDB步骤非常的简单,这里不做介绍.但是如果你安装的时候没有将MongoDB作为服务运行,每次你都要使用cmd切换到指定的目录下,然后在cmd中启动M ...
First Blog
俗话说“笨鸟先飞”,遗憾的是我这只笨鸟直到今天才意识到个人博客的重要性. 原来记录下学习生活中的每一丝领悟与思考,可以让个人内在,对知识的理解得到更好的升华. 有梦的人很美,追梦的人更美.像我的座右铭 ...

python计算器

python计算器的更多相关文章

随机推荐

热门专题