Python實現的複雜的計算器的代碼

時間 2019-11-29

標籤 python 實現複雜計算器代碼欄目 Python 简体版

原文原文鏈接

用Python實現複雜的計算器，能夠按照「（）」、乘除、加減的優先級進行混合運算。主旨是對正則表達式進行學習。正則表達式

設計思路：app

　　1.在計算式中搜索最後一個「（」，再搜索和它匹配的「）」，截取兩個括號間的表達式cul。學習

　　2.乘除的優先級高，循環搜索cul內的乘除號，進行計算後進行加減計算，獲得結果ans。spa

　　3.用ans替換「（cul）」，從新搜索括號，知道將輸入的公式簡化成沒有括號的四則運算。設計

　　4.對最後的四則運算計算結果。流程圖以下：日誌

設計時的注意事項：code

　　1.在簡化計算式過程當中，如3*（1-3），簡化後爲3*-2，在進行乘運算的時候會報錯。解決措施爲將乘數前的負號移至被乘數前。將算術式更換爲-3*2。除法也用相同的方法處理。blog

　　2.在出現「--」或「+-」的時候，能夠把「--」替換成「+」，把「+-」替換成「-」。索引

代碼分析：字符串

代碼的結構是這樣的：

執行文件其實沒啥說的！

1 import os,sys
2 BASE_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
3 print(BASE_dir)
4 sys.path.append(BASE_dir)
5 from core import main
6 if __name__ == '__main__':
7     main.run()

calculato.py就是將文件路徑添加到環境變量中

 1 import re
 2 def mul(processor):　　　　　　#乘運算
 3     a = re.search(r"(\d+)?[.]?(\d+)[*]", processor).group()[:-1]
 4     b = re.search(r"[*]\d+[.]?(\d+)?", processor).group()[1:]
 5     ans = float(a) * float(b)
 6     ans = str(ans)
 7     processor_past = re.sub(r"\d+[.]?(\d+)?[*]\d+[.]?(\d+)?", ans, processor, count=1)
 8     return processor_past
 9 def div(processor):　　　　    #除運算
10     a = re.search(r"(\d+)?[.]?(\d+)[/]", processor).group()[:-1]
11     b = re.search(r"[/]\d+[.]?(\d+)?", processor).group()[1:]
12     ans = float(a) / float(b)
13     ans = str(ans)
14     processor_past = re.sub(r"\d+[.]?(\d+)?[/]\d+[.]?(\d+)?", ans, processor, count=1)
15     return processor_past
16 def add(processor):　　　　　　#加運算
17     a=re.search("(\d+)?[.]?(\d+)[+]",processor).group()[:-1]
18     b=re.search("[+]\d+[.]?(\d+)?",processor).group()[1:]
19     ans = float(a)+float(b)
20     ans = str(ans)
21     processor_past = re.sub(r"\d+[.]?(\d+)?[+]\d+[.]?(\d+)?",ans,processor,count=1)
22     return processor_past
23 def sub(processor):　　　　　　#減運算
24     a=re.search("\d+[.]?(\d+)?[-]",processor).group()[:-1]
25     b=re.search("[-]\d+[.]?(\d+)?",processor).group()[1:]
26     ans = float(a)-float(b)
27     ans = str(ans)
28     processor_past = re.sub(r"\d+[.]?(\d+)?[-]\d+[.]?(\d+)?",ans,processor,count=1)
29     return processor_past

在func.py中定義了運算的方法，因爲形參是字符串形式，需將計算結果轉換成字符串，而後將結果和算術式替換：如mul("3*2+1)的返回值是「6+1」。

這裏還用了字符串的切片方法，刪掉第一個值:[1:]，刪掉最後一個值爲[:-1]。

以乘法爲例，"*"前必須爲數字，被乘數是小數的話還會有小數點和整數位，因此在正則表達式的查詢關鍵字爲r「(\d+)?[.]?(\d+)[*]」，所引出字符串後刪掉最後的「*」，而「*」後緊跟的是數字，小數點和小數點後的數爲非必須字符。用r"[*]\d+[.]?(\d+)?"查找。

在查詢關鍵字時「*"和」+「爲轉義字符，要在字符串前加」r「

 1 import re
 2 from core import func
 3 def find_brackets(cul):         #將「（）」內表達式分析出來
 4     while re.search("[(].+", cul):
 5         cul = re.search("[(].+", cul).group()[1:]
 6     cul = cul[::-1]
 7     while re.search("[)].+", cul):
 8         cul = re.search("[)].+", cul).group()[1:]
 9     cul = cul[::-1]
10     return (cul)
11 
12 def change(search,ans,cul):                 #將運算結果和（）裏的表達式更換
13     search = re.sub("[+]", '\+',search)
14     search = re.sub("[*]", '\*',search)
15     cul = re.sub("[(]%s[)]"%search,ans,cul)#在正則表達式中插入變量
16     return cul
17 
18 def change_minus(search, ans, before):              # 和move_minus一塊兒移動乘除號後面的負號
19     search = re.sub("[+]", '\+', search)
20     search = re.sub("[*]", '\*', search)
21     after = re.sub(search, ans, before)
22     return after
23 
24 def move_minus(cul):
25     b = cul
26     if re.search(r"(\d+)?[.]?\d+[*][-](\d+)?[.]?\d+?", cul):
27         a = re.search(r"(\d+)?[.]?\d+[*][-](\d+)?[.]?\d+?", cul).group()
28         c = a
29         a = re.sub("[-]", "", a)
30         a = '-' + a
31         b = change_minus(c, a, cul)
32     elif re.search(r"(\d+)?[.]?\d+[/][-](\d+)?[.]?\d+?", cul):
33         a = re.search(r"(\d+)?[.]?\d+[/][-](\d+)?[.]?\d+?", cul).group()
34         c = a
35         a = re.sub("[-]", "", a)
36         a = '-' + a
37         b = change_minus(c, a, cul)
38     return b
39 
40 
41 def mul_div(str_past):                                              #乘除優先級一致，進行乘除運算
42     ans = str_past
43     while re.search("[\*]|[/]",ans):
44         res = re.search("[/]|[\*]",ans).group()
45         if res == "*":
46             ans = func.mul(ans)
47         elif res =="/":
48             ans = func.div(ans)
49     return ans
50 
51 def add_reduce(str_past):                                           #加減優先級一致，進行加減運算
52     ans = str_past
53     ans = re.sub("--","+",ans)
54     ans = re.sub(r"[+][-]","-",ans)
55     while re.search(r"[+]|[-]",ans):
56         if re.match("-",ans):
57             break
58         else:
59             res = re.search(r"[+]|[-]",ans).group()
60             if res == "+":
61                 ans = func.add(ans)
62             elif res =="-":
63                 ans = func.sub(ans)
64     return ans
65 
66 def cul(str):
67     cul = str
68     ans = str
69     while re.search("[(]",cul):
70         cul = re.sub("--", "+", cul)
71         cul = re.sub(r"[+][-]", "-", cul)
72         cul_1 = find_brackets(cul)
73         ans = mul_div(cul_1)
74         ans = add_reduce(ans)
75         ans = change(cul_1,ans,cul)
76         cul = ans
77         cul = move_minus(cul)
78     ans = move_minus(ans)
79     ans = mul_div(ans)
80     ans = add_reduce(ans)
81     return ans

calcu.py定義了整個計算的流程。

cul()中不斷索引括號，將索引出的算術式計算後用結論替代。每簡化一輪後檢查乘除號後是否有負號的狀態。

乘除法的優先級比加減高，能夠把乘除的運算放在一塊兒，

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

用這個方法能夠從左到右循環搜索算術式內的乘除運算。

 1 import re
 2 import os,sys
 3 from core import calcu,func.log
 4 def run():
 5     print("歡迎使用計算器！！！")
 6     while True:
 7         cul = input("請輸入計算公式：")
 8         if cul == "exit":
 9             print("退出計算器！")
10             break
11         elif re.findall("[(]", cul).__len__() != re.findall("[)]", cul).__len__():
12             print("括號不匹配！")
13         elif re.search("[（]|[）]",cul):
14             print("請使用英文符號！")
15         elif re.search("[a-z]|[A-Z]",cul):
16             print("請輸入數字！")
17         else:
18             ans = calcu.cul(cul)
19             print(ans)
20             log.logger(cul,ans)

main.py調用了整個算式的計算過程，並對輸入的公式進行了一些糾錯措施並在每次計算後將計算式和結論存儲在日誌中。

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