Python之实现⼀个简易计算器
⾃⼰动⼿写计算器
⼀、功能分析
⽤户输⼊⼀个类似这样 3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4) 这样的表达式，假设表达式⾥⾯除了包含空格、'+'、'-'、'*'、'/'和括号再⽆其他特殊符号，然后⾃⼰动⼿写代码解析其中的表达式，实现加减乘除，最后得出的结果与真实的计算机所算的结果必须⼀致。
⼆、所需的知识点
字符串的处理
正则表达式的运⽤
函数递归
三、程序实现流程分析
1. ⽤正则表达式处理字符串，只提取其中的数字和运算符，并转换成列表
2. 编写⼀个函数，处理没有括号的基本运算的基本表达式
3. 再写⼀个函数递归处理带有括号的函数，先计算最内部括号中的表达式, 然后将最内部的括号替换为计算后的结果, 在递归外部⼀层的,
最后返回的就是所需的结果
四、具体实现过程
1.正则表达式处理⽤户输⼊字符串
这⾥我不会讲正则表达式具体的⽤法，要将的话都可以讲⼀本书了，我只讲本⽂⽤到的正则表达式。根据需求，我们需要提取出⽤户输⼊字符串中的数字和运算符到⼀个列表中，⽽空格将会被忽略掉，假设⽤户输⼊的表达式是 expression，我们可以写出下⾯的代码：
1 2 3 4import 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 18import 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
while1: #先将乘除运算计算完，在计算加减
if'*'in l and'/'not in l: #先判断，如果只有*的话，先计算 *
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 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 39def 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)
while1: #先将乘除运算计算完，在计算加减
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])
39 40 41 42 43 44 45 46 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 16def 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 34import 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
while1:
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]
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 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 24import 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)) ==place(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]vb计算器代码大全
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])
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 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 =place(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函数即可算出结果。看到这⾥，是不是有点泪奔的感觉，⽩写了。其实不然，通过我们⾃⼰写，可以更好的理解实现的原理，并且加强⾃⼰写代码的能⼒。
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论