自己动手写计算器

一、功能分析

　　用户输入一个类似这样 3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4) 这样的表达式，假设表达式里面除了包含空格、'+'、'-'、'*'、'/'和括号再无其他特殊符号，然后自己动手写代码解析其中的表达式，实现加减乘除，最后得出的结果与真实的计算机所算的结果必须一致。

二、所需的知识点

  • 字符串的处理
  • 正则表达式的运用
  • 函数递归

三、程序实现流程分析

  1. 用正则表达式处理字符串，只提取其中的数字和运算符，并转换成列表
  2. 编写一个函数，处理没有括号的基本运算的基本表达式
  3. 再写一个函数递归处理带有括号的函数，先计算最内部括号中的表达式, 然后将最内部的括号替换为计算后的结果, 在递归外部一层的, 最后返回的就是所需的结果

四、具体实现过程

1.正则表达式处理用户输入字符串

　　这里我不会讲正则表达式具体的用法，要将的话都可以讲一本书了，我只讲本文用到的正则表达式。根据需求，我们需要提取出用户输入字符串中的数字和运算符到一个列表中，而空格将会被忽略掉，假设用户输入的表达式是 expression，我们可以写出下面的代码：

1
2
3
4
import re
expression='(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)'
l=re.findall('([\d\.]+|/|-|\+|\*)',expression)
print(l) #['100', '+', '40', '*', '5', '/', '2', '-', '3', '*', '2', '*', '2', '/', '4', '+', '9', '*', '3', '+', '4', '-', '4', '-', '4']　

首先我们先看一下 findall 的用法，findall可以匹配所有符合规律的内容，返回包含结果的列表。'([\d\.]+|/|-|\+|\*)'是匹配规则，这里\d表示匹配一个数字，\.表示将.转义成数字上小数点 . ，不然在正则表达式里 . 可以匹配除了换行符以外的任意字符。[\d\.]+表示可以匹配至少由一个数字、或者小数点 . 组成的字符串，比如说，这里既可以匹配到100，也可以匹配到100.11。|/|-|\+|\* 表示匹配到+或-或*或/，()表示一组，这里意思是如果匹配到数字或者+或者-或者*或者/其中任意一个的话，就将其作为一组，然后添加到列表中去。

2.不含括号的表达式的计算

　　为了后面迭代算出有括号的表达式，我们先写一个没有括号的表达式，比如说像这样一个表达式 '100.5+40*5/2-3*2*2/4+9',对于这样的表达式我们肯定是计算乘除，在计算加减，计算一个最小计算单元后，再将结果放回列表中不断循环，直到算出整个不带括号的表达式，实现的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import re
expression= '100.5+40*5/2-3*2*2/4+9'
l = re.findall('([\d\.]+|/|-|\+|\*)',expression)
print(100.5+40*5/2-3*2*2/4+9)                     # 206.5
def multdiv(l,x):                                 #定义最小的乘除运算单元，l是列表，x代表*或/
    a = l.index(x)                                #首先获取乘除运算符的位置
    if x=='*':                                    #如果是*则执行乘法运算
        k = float(l[a - 1]) * float(l[a + 1])     #获取乘法运算的结果，比如k=3*2
    else:
        k = float(l[a - 1]) / float(l[a + 1])
    del l[a - 1], l[a - 1], l[a - 1]              #删除掉列表里刚做运算的三个元素，比如，3 * 2
    l.insert(a - 1, str(k))                       #将刚计算的结果插入到列表中然后执行下一次计算
    return l
 
def fun(s):
    sum=0
    while 1:                                     #先将乘除运算计算完，在计算加减
        if '*' in l and '/' not in l:            #先判断，如果只有*的话，先计算 *
            multdiv(l, '*')
        elif '*' not in l and '/' in l:          #如果只有 /的话，先计算 /
            multdiv(l, '/')
        elif '*' in l and '/' in l:              #如果既有 / 也有 *的话，先获取他们的下标，
            a = l.index('*')                     #根据下标判断先执行哪个
            b = l.index('/')
            if a < b:
                multdiv(l, '*')
            else:
                multdiv(l, '/')
        else:                                   #当上面的乘除计算完之后，就可以计算加减了
            if l[0]=='-':                       #这里需要判断一下，如果列表里第一个符号是‘-’
                l[0]=l[0]+l[1]                  #的话，表示第一个数是负数，所以我们需要将列表第一和第二项合并起来
                del l[1]
            sum += float(l[0])                  #做完上面的处理后列表中就只剩加减计算了，
            for i in range(1,len(l),2):
                if l[i]=='+':                   #根据符号执行加减计算，将结果保存在sum中
                    sum+=float(l[i+1])
                else:
                    sum-=float(l[i+1])
            break
    return  sum                                 #最后返回这个不含括号表达式的结果
a=fun(l)
print(a)                                        # 206.5 可以看出与实际的计算结果一样

　　代码写到这里主要的功能实现了，但是上面的代码还有一个小问题，那就是如果我们的表达式如果是这样的 7*((1-4)-4) 我们按照程序流程执行的话执行一次fun的话，表达式变成这样 7*(-3-4),在执行一次的话就变成 7*-7，这样的话，我们在执行上面的fun函数就会出现问题，因为两个数字之间出现了两个运算符，所以我们要修改上面的函数使其能处理这种情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def multdiv(l,x):                                　　#定义最小的乘除运算单元，l是列表，x代表*或/
    a = l.index(x)                                  #首先获取乘除运算符的位置
    if x == '*' and l[a + 1] != '-':                #判断*，/后面的一个操作符是否是‘-’如果是的话，分别进行处理
        k = float(l[a - 1]) * float(l[a + 1])
    elif x == '/' and l[a + 1] != '-':
        k = float(l[a - 1]) / float(l[a + 1])
    elif x == '*' and l[a + 1] == '-':
        k = -(float(l[a - 1]) * float(l[a + 2]))
    elif x == '/' and l[a + 1] == '-':
        k = -(float(l[a - 1]) / float(l[a + 2]))
    del l[a - 1], l[a - 1], l[a - 1]                #删除掉列表里刚做运算的三个元素，比如，3 * 2
    l.insert(a - 1, str(k))                         #将刚计算的结果插入到列表中然后执行下一次计算
    return l
 
def fun(l):
    sum=0
    print(l)
    while 1:                                     #先将乘除运算计算完，在计算加减
        if '*' in l and '/' not in l:            #先判断，如果只有*的话，先计算 *
            multdiv(l, '*')
        elif '*' not in l and '/' in l:          #如果只有 /的话，先计算 /
            multdiv(l, '/')
        elif '*' in l and '/' in l:              #如果既有 / 也有 *的话，先获取他们的下标，
            a = l.index('*')                     #根据下标判断先执行哪个
            b = l.index('/')
            if a < b:
                multdiv(l, '*')
            else:
                multdiv(l, '/')
        else:                                              #当上面的乘除计算完之后，就可以计算加减了
            print(l)
            if l[0]=='-':                                  #这里需要判断一下，如果列表里第一个符号是‘-’
                l[0]=l[0]+l[1]                  　　　　　　 #的话，表示第一个数是负数，所以我们需要将列表第一和第二项合并起来
                del l[1]
            sum += float(l[0])                  　　　　　　 #做完上面的处理后列表中就只剩加减计算了，
            for i in range(1, len(l), 2):
                if l[i] == '+' and l[i + 1] != '-':  　　   #判断+，-后面的一个操作符是否是‘-’如果是的话，分别进行处理
                    sum += float(l[i + 1])
                elif l[i] == '+' and l[i + 1] == '-':
                    sum -= float(l[i + 2])
                elif l[i] == '-' and l[i + 1] == '-':
                    sum += float(l[i + 2])
                elif l[i] == '-' and l[i + 1] != '-':
                    sum -= float(l[i + 1])
            break
    return  sum                                 　　　　   #最后返回这个不含括号表达式的结果

到这里，我们就完成了不含括号表达式的运算，程序的一大半就完成了，下面我们在完成剩下的程序。

3.带有括号表达式的递归计算

首先计算最里面一个括号里的表达式，调用fun函数计算出其值，将其结果代替其括号，然后不停的递归调用直到获取最后的结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def calculate(expression):
    ex=[]                       #存储'('出现的位置
    ans=0                       #保存结果
    if '(' not in expression:   #如果括号都处理完成了，直接调用fun函数返回结果
        ans=fun(expression)
        return ans
    for i in range(len(expression)):
        if expression[i]=='(':
            ex.append(i) #ex=[6,7]                          #纪录 '(' 出现的位置
        elif expression[i]==')':                            #遇到 ')'后。就可以计算第一个括号里的值
            temp=0                                          #定义一个变量 存储括号表达式的结果
            sub=expression[ex[len(ex)-1]+1:i]               #获取括号里的表达式
            temp=fun(sub)                                   #调用fun函数计算括号里的表达式的值
            expression=expression[0:ex[len(ex)-1]]+str(temp)+expression[i+1:len(expression)+1]  #去掉刚才的括号表达式，并用temp代替，返回一个新的表达式
            ex.pop()                                        #删除刚才计算完的括号表达式里面 '(' 的位置
            return calculate(expression)                    #递归计算新的表达式，直道所有的括号处理完毕

4.大功告成

到这里所有的模块都完成了，一个简单的计算器就实现了，下面附上完整的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import re
def md(l,x):
    a = l.index(x)
    if x == '*' and l[a + 1] != '-':
        k = float(l[a - 1]) * float(l[a + 1])
    elif x == '/' and l[a + 1] != '-':
        k = float(l[a - 1]) / float(l[a + 1])
    elif x == '*' and l[a + 1] == '-':
        k = -(float(l[a - 1]) * float(l[a + 2]))
    elif x == '/' and l[a + 1] == '-':
        k = -(float(l[a - 1]) / float(l[a + 2]))
    del l[a - 1], l[a - 1], l[a - 1]
    l.insert(a - 1, str(k))
    return l
 
def fun(s):
    l = re.findall('([\d\.]+|/|-|\+|\*)',s)
    sum=0
    while 1:
        if '*' in l and '/' not in l:
            md(l, '*')
        elif '*' not in l and '/' in l:
            md(l, '/')
        elif '*' in l and '/' in l:
            a = l.index('*')
            b = l.index('/')
            if a < b:
                md(l, '*')
            else:
                md(l, '/')
        else:
            if l[0]=='-':
                l[0]=l[0]+l[1]
                del l[1]
            sum += float(l[0])
            for i in range(1, len(l), 2):
                if l[i] == '+' and l[i + 1] != '-':
                    sum += float(l[i + 1])
                elif l[i] == '+' and l[i + 1] == '-':
                    sum -= float(l[i + 2])
                elif l[i] == '-' and l[i + 1] == '-':
                    sum += float(l[i + 2])
                elif l[i] == '-' and l[i + 1] != '-':
                    sum -= float(l[i + 1])
            break
    return sum
def calculate(expression):
    ex=[]
    ans=0
    if '(' not in expression:
        ans=fun(expression)
        return ans
    for i in range(len(expression)):
        if expression[i]=='(':
            ex.append(i) #ex=[6,7]
        elif expression[i]==')': #14
            temp=0
            sub=expression[ex[len(ex)-1]+1:i]
            temp=fun(sub)
            expression=expression[0:ex[len(ex)-1]]+str(temp)+expression[i+1:len(expression)+1]
            ex.pop()
            return calculate(expression)
 
s='1 - 2 * ( (60-30 +(-40/5+3) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
print(1 - 2 * ( (60-30 +(-40/5+3) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ))  　　#1735397.4095238098
s3='3*(4+50)-((100+40)*5/2-3*2*2/4+9)*(((3+4)-4)-4)'  　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #518.0
print(3*(4+50)-((100+40)*5/2-3*2*2/4+9)*(((3+4)-4)-4))
print(calculate(s))   　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#1735397.4095238098
print(calculate(s3)) 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #518.0

　　为了简洁性，上面完整的代码没有写注释，要看注释的话可以往文章的上面去查看，最后为了可以简单的对比计算器的正确性，就没有加入input部分来获取用户的输入，直接在代码中用字符串代替了，代码的最后可以看出代码正确的运行了，到这里简易计算器就完成了。

五、补充

　　最近深入的学一下正则表达式，发现上面写的计算器，比较复杂，所以就想用正则在经行改写一下，下面是改写后的代码，改写后去除注释不到40行代码，非常简洁，下面来看一下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import re
def multiply_divide(s):                 　　　　　　　　#计算一个不含括号的最小乘除单元，用split分隔*或/然后计算
    ret = float(s.split('*')[0]) * float(s.split('*')[1]) if '*' in s else float(s.split('/')[0]) / float(
        s.split('/')[1])
    return ret
 
def remove_md(s):                       　　　　　　　　# 将不含括号的表达式里的乘除先递归计算完
    if '*' not in s and '/' not in s:
        return s                        　　　　　　　　# 没有乘除的话递归结束
    else:                               　　　　　　　　# 匹配一个最小乘除单元，调用multiply_divide计算，将结果拼接成一个新的表达式进行递归处理
        k = re.search(r'-?[\d\.]+[*/]-?[\d\.]+', s).group()
        s = s.replace(k, '+' + str(multiply_divide(k))) if len(re.findall(r'-', k)) == 2 else s.replace(k, str(
            multiply_divide(k)))
        return remove_md(s)
 
def add_sub(s):                          　　　　　　　　# 计算没有乘除的表达式，得出最后不包含括号表达式的运算结果
    l = re.findall('([\d\.]+|-|\+)', s) 　　　　　　　　 # 将表达式转换成列表，
    if l[0] == '-':                      　　　　　　　　# 如果第一个数是负数，对其进行处理
        l[0] = l[0] + l[1]
        del l[1]
    sum = float(l[0])
    for i in range(1, len(l), 2):        　　　　　　　　# 循环计算结果
        if l[i] == '+' and l[i + 1] != '-':
            sum += float(l[i + 1])
        elif l[i] == '+' and l[i + 1] == '-':
            sum -= float(l[i + 2])
        elif l[i] == '-' and l[i + 1] == '-':
            sum += float(l[i + 2])
        elif l[i] == '-' and l[i + 1] != '-':
            sum -= float(l[i + 1])
    return sum
 
def basic_operation(s):                 　　　　　　　　　　# 计算一个基本的4则运算
    s = s.replace(' ', '')
    return add_sub(remove_md(s))        　　　　　　　　　　# 调用前面定义的函数，先乘除，后加减
 
def calculate(expression):             　　　　　　　　　　 # 计算包含括号的表达式
    if not re.search(r'\([^()]+\)', expression):                    # 匹配最里面的括号，如果没有的话，直接进行运算，得出结果
        return basic_operation(expression)
    k = re.search(r'\([^()]+\)', expression).group()                # 将匹配到的括号里面的表达式交给basic_operation处理后重新拼接成字符串递归处理
    expression = expression.replace(k, str(basic_operation(k[1:len(k) - 1])))
    return calculate(expression)
 
s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
print('用eval计算出来的值为：{}\n计算器计算出来的值为：{}'.format(eval(s), calculate(s)))
# >>> 用eval计算出来的值为：2776672.6952380957
# >>> 计算器计算出来的值为：2776672.6952380957　

六、小结　

　　看了上面的代码，是不是觉自己写代码还是好麻烦啊，那么Python有没有已经写好的函数帮我们完成这一功能了，作为追求简洁的python来说必须有，一行代码解决上面我们做的所有事，而且功能更加完善，那就是eval()函数，只需将要计算的表达式传递给eval函数即可算出结果。看到这里，是不是有点泪奔的感觉，白写了。其实不然，通过我们自己写，可以更好的理解实现的原理，并且加强自己写代码的能力。

　　

Python之实现一个简易计算器的更多相关文章

  1. 前端 JavaScript 实现一个简易计算器

    前端使用 JavaScript 实现一个简易计算器,没有难度,但是里面有些小知识还是需要注意的,算是一次基础知识回顾吧. 题目 实现一个简易版的计算器,需求如下: 1.除法操作时,如果被除数为0,则结 ...

  2. 如何使用Java AWT 创建一个简易计算器

    摘要:手把手教你使用 Java AWT 创建一个简易计算器. 本文分享自华为云社区<手把手教你使用 Java AWT 创建一个简易计算器>,作者:海拥 . 关于AWT AWT (抽象窗口工 ...

  3. 制作一个简易计算器——基于Android Studio实现

    一个计算器Android程序的源码部分分为主干和细节两部分. 一.主干 1. 主干的构成 计算器的布局 事件(即计算器上的按钮.文本框)监听 实现计算 2. 详细解释 假设我们的项目名为Calcula ...

  4. Python scapy 实现一个简易 arp 攻击脚本

    原文链接:http://www.jianshu.com/p/df5918069612 scapy 是 python 写的一个功能强大的交互式数据包处理程序,可用来发送.嗅探.解析和伪造网络数据包,常常 ...

  5. Python Django 编写一个简易的后台管理工具4-添加admin模版

    导入admin后台模版 可以在网上任意搜索模版,我这里也提供一个地址github 拷贝admin后台的html文件至项目的templates文件夹 创建static文件夹,将admin后台的js,im ...

  6. python之做一个简易的翻译器(二)

    把写好的python程序转换为windows系统下可以运行的exe文件 使用pyinstaller命令来进行转换 1.首先安装pyinstaller 可以在pycharm中安装,也可以直接使用pip命 ...

  7. python之做一个简易的翻译器(一)

    平时经常在网上翻译一些单词,突发奇想,可不可以直接调某些免费翻译网站的接口呢?然后做一个图形界面的翻译小工具?下面开始实践 1.先找一下有哪些免费翻译的接口 百度了一下关键字“免费翻译接口”,然后找到 ...

  8. 用jQ实现一个简易计算器

    HTML和CSS结构: <!DOCTYPE html> <html lang="en"> <head> <meta charset=&qu ...

  9. python -Tkinter 实现一个小计算器功能

    文章来源:http://www.cnblogs.com/Skyyj/p/6618739.html 本代码是基于python 2.7的 如果是对于python3.X  则需要将 tkinter 改为Tk ...

随机推荐

  1. hadoop-2.6.0.tar.gz + spark-1.5.2-bin-hadoop2.6.tgz的集群搭建（单节点）

    前言 本人呕心沥血所写,经过好一段时间反复锤炼和整理修改.感谢所参考的博友们!同时,欢迎前来查阅赏脸的博友们收藏和转载,附上本人的链接.http://www.cnblogs.com/zlslch/p/ ...

  2. PC-删除共享[绝对够狠的方法]

    1.批处理清除法-------------------------------------------------------------------------------------------- ...

  3. fedora21安装xmind7

    老版本的xmind安装方法,在最后的阶段无法成功注册到系统中,desktop无法自定义完成．参考:http://www.cnblogs.com/cupcoffee/p/3560626.html 直到从 ...

  4. 自己动手Jquery插件

    最近Web应用程序中越来越多地用到了JQuery等Web前端技术.这些技术框架有效地改善了用户的操作体验,同时也提高了开发人员构造丰富客户 端UI的效率.JQuery本身提供了丰富的操作,但是,有时候 ...

  5. ConversionException: No value specified for 'Date'的解决版本

    DateConverter converter = new DateConverter(defaultValue); ConvertUtils.register(converter, java.uti ...

  6. UEFI引导修复教程和工具

    参考 http://bbs.wuyou.com/forum.php?mod=viewthread&tid=323759 1. MBR分区表:Master Boot Record,即硬盘主引导记 ...

  7. 【转】http响应状态代码含义及跳转的类型

    转自:http://www.west263.com/info/html/caozuoxitong/FreeBSD/20090513/123479.html 当我们在因特网遨游的时候,每天都会看到诸如5 ...

  8. C++ 实现按随意键继续~~~

    近期让学生敲代码交作业的时候要求他们仅仅给我交个cpp文件和一个exe文件,这样交上来的东西不至于太多,不占我的地方,可是有一个问题是exe它总是执行完后就直接关闭界面了,看不到执行结果的界面. 然后 ...

  9. ListView视图缓存错位问题

    由于之前写Scroller应用:ListView滑动删除遇到Item视图错位问题,观察发现第1item位置改变后,第1+10的item布局也跟着改变.假设使用ScrollView+ListView,把 ...

  10. sendStickyBroadcast和sendStickyOrderedBroadcast

    sendStickyBroadcast和sendStickyOrderedBroadcast发出的广播会一直滞留(等待),以便有人注册这则广播消息后能尽快的收到这条广播.其他功能与sendBroadc ...