Python实现的复杂的计算器的代码

用Python实现复杂的计算器，可以按照“（）”、乘除、加减的优先级进行混合运算。主旨是对正则表达式进行学习。

设计思路：

　　1.在计算式中搜索最后一个“（”，再搜索和它匹配的“）”，截取两个括号间的表达式cul。

　　2.乘除的优先级高，循环搜索cul内的乘除号，进行计算后进行加减计算，得到结果ans。

　　3.用ans替换“（cul）”，重新搜索括号，知道将输入的公式简化成没有括号的四则运算。

　　4.对最后的四则运算计算结果。流程图如下：

设计时的注意事项：

　　1.在简化计算式过程中，如3*（1-3），简化后为3*-2，在进行乘运算的时候会报错。解决措施为将乘数前的负号移至被乘数前。将算术式更换为-3*2。除法也用相同的方法处理。

　　2.在出现“--”或“+-”的时候，可以把“--”替换成“+”，把“+-”替换成“-”。

代码分析：

代码的结构是这样的：

执行文件其实没啥说的！

 import os,sys
 BASE_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 print(BASE_dir)
 sys.path.append(BASE_dir)
 from core import main
 if __name__ == '__main__':
     main.run()

calculato.py就是将文件路径添加到环境变量中

 import re
 def mul(processor):　　　　　　#乘运算
     a = re.search(r"(\d+)?[.]?(\d+)[*]", processor).group()[:-1]
     b = re.search(r"[*]\d+[.]?(\d+)?", processor).group()[1:]
     ans = float(a) * float(b)
     ans = str(ans)
     processor_past = re.sub(r"\d+[.]?(\d+)?[*]\d+[.]?(\d+)?", ans, processor, count=1)
     return processor_past
 def div(processor):　　　　    #除运算
     a = re.search(r"(\d+)?[.]?(\d+)[/]", processor).group()[:-1]
     b = re.search(r"[/]\d+[.]?(\d+)?", processor).group()[1:]
     ans = float(a) / float(b)
     ans = str(ans)
     processor_past = re.sub(r"\d+[.]?(\d+)?[/]\d+[.]?(\d+)?", ans, processor, count=1)
     return processor_past
 def add(processor):　　　　　　#加运算
     a=re.search("(\d+)?[.]?(\d+)[+]",processor).group()[:-1]
     b=re.search("[+]\d+[.]?(\d+)?",processor).group()[1:]
     ans = float(a)+float(b)
     ans = str(ans)
     processor_past = re.sub(r"\d+[.]?(\d+)?[+]\d+[.]?(\d+)?",ans,processor,count=1)
     return processor_past
 def sub(processor):　　　　　　#减运算
     a=re.search("\d+[.]?(\d+)?[-]",processor).group()[:-1]
     b=re.search("[-]\d+[.]?(\d+)?",processor).group()[1:]
     ans = float(a)-float(b)
     ans = str(ans)
     processor_past = re.sub(r"\d+[.]?(\d+)?[-]\d+[.]?(\d+)?",ans,processor,count=1)
     return processor_past

在func.py中定义了运算的方法，由于形参是字符串形式，需将计算结果转换成字符串，然后将结果和算术式替换：如mul("3*2+1)的返回值是“6+1”。

这里还用了字符串的切片方法，删掉第一个值:[1:]，删掉最后一个值为[:-1]。

以乘法为例，"*"前必须为数字，被乘数是小数的话还会有小数点和整数位，所以在正则表达式的查询关键字为r“(\d+)?[.]?(\d+)[*]”，所引出字符串后删掉最后的“*”，而“*”后紧跟的是数字，小数点和小数点后的数为非必须字符。用r"[*]\d+[.]?(\d+)?"查找。

在查询关键字时“*"和”+“为转义字符，要在字符串前加”r“

 import re
 from core import func
 def find_brackets(cul):         #将“（）”内表达式分析出来
     while re.search("[(].+", cul):
         cul = re.search("[(].+", cul).group()[1:]
     cul = cul[::-1]
     while re.search("[)].+", cul):
         cul = re.search("[)].+", cul).group()[1:]
     cul = cul[::-1]
     return (cul)

 def change(search,ans,cul):                 #将运算结果和（）里的表达式更换
     search = re.sub("[+]", '\+',search)
     search = re.sub("[*]", '\*',search)
     cul = re.sub("[(]%s[)]"%search,ans,cul)#在正则表达式中插入变量
     return cul

 def change_minus(search, ans, before):              # 和move_minus一起移动乘除号后面的负号
     search = re.sub("[+]", '\+', search)
     search = re.sub("[*]", '\*', search)
     after = re.sub(search, ans, before)
     return after

 def move_minus(cul):
     b = cul
     if re.search(r"(\d+)?[.]?\d+[*][-](\d+)?[.]?\d+?", cul):
         a = re.search(r"(\d+)?[.]?\d+[*][-](\d+)?[.]?\d+?", cul).group()
         c = a
         a = re.sub("[-]", "", a)
         a = '-' + a
         b = change_minus(c, a, cul)
     elif re.search(r"(\d+)?[.]?\d+[/][-](\d+)?[.]?\d+?", cul):
         a = re.search(r"(\d+)?[.]?\d+[/][-](\d+)?[.]?\d+?", cul).group()
         c = a
         a = re.sub("[-]", "", a)
         a = '-' + a
         b = change_minus(c, a, cul)
     return b

 def mul_div(str_past):                                              #乘除优先级一致，进行乘除运算
     ans = str_past
     while re.search("[\*]|[/]",ans):
         res = re.search("[/]|[\*]",ans).group()
         if res == "*":
             ans = func.mul(ans)
         elif res =="/":
             ans = func.div(ans)
     return ans

 def add_reduce(str_past):                                           #加减优先级一致，进行加减运算
     ans = str_past
     ans = re.sub("--","+",ans)
     ans = re.sub(r"[+][-]","-",ans)
     while re.search(r"[+]|[-]",ans):
         if re.match("-",ans):
             break
         else:
             res = re.search(r"[+]|[-]",ans).group()
             if res == "+":
                 ans = func.add(ans)
             elif res =="-":
                 ans = func.sub(ans)
     return ans

 def cul(str):
     cul = str
     ans = str
     while re.search("[(]",cul):
         cul = re.sub("--", "+", cul)
         cul = re.sub(r"[+][-]", "-", cul)
         cul_1 = find_brackets(cul)
         ans = mul_div(cul_1)
         ans = add_reduce(ans)
         ans = change(cul_1,ans,cul)
         cul = ans
         cul = move_minus(cul)
     ans = move_minus(ans)
     ans = mul_div(ans)
     ans = add_reduce(ans)
     return ans

calcu.py定义了整个计算的流程。

cul()中不断索引括号，将索引出的算术式计算后用结论替代。每简化一轮后检查乘除号后是否有负号的状态。

乘除法的优先级比加减高，可以把乘除的运算放在一起，

while re.search("[\*]|[/]",ans):

用这个方法可以从左到右循环搜索算术式内的乘除运算。

 import re
 import os,sys
 from core import calcu,func.log
 def run():
     print("欢迎使用计算器！！！")
     while True:
         cul = input("请输入计算公式：")
         if cul == "exit":
             print("退出计算器！")
             break
         elif re.findall("[(]", cul).__len__() != re.findall("[)]", cul).__len__():
             print("括号不匹配！")
         elif re.search("[（]|[）]",cul):
             print("请使用英文符号！")
         elif re.search("[a-z]|[A-Z]",cul):
             print("请输入数字！")
         else:
             ans = calcu.cul(cul)
             print(ans)
             log.logger(cul,ans)

main.py调用了整个算式的计算过程，并对输入的公式进行了一些纠错措施并在每次计算后将计算式和结论存储在日志中。

 import time
 def logger(cul,ans):
     fp = open("logger.txt",'a+',encoding="UTF-8")
     now = time.time()
     fp.write("%s     %s=%s\n"%(now,cul,ans))
     fp.close()

log.py就是将每次运算的公式和结论存储在日志中。

存在的问题：日志文件应存储在log路径下，但是现在每次执行完会在bin路径下生成新日志文件并进行存储操作。还在想办法改进中！