用python編寫一個簡單計算器

計算器開發需求 實現加減乘除及拓號優先順序解析 使用者輸入 # 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) # 等類似算式後，必須自己解析裡面的(),+,-,*,/符號和公式,利用遞迴演算法

拿到這個題目時，感覺無從下手。老師說利用開學來3天學習的知識是可以做出來的。然後我認真歸納總結前3天學習的基礎知識，經過3天3夜的奮戰終於給弄出來了。雖然中途也有想過放棄，但是沒有耕耘哪來的收穫。如果初學的同學想借鑑的話， 建議自己先仔細想想，如果實在無從下手可以參考下我的。特寫此文以自勉。程式中可能出現很多冗餘或bug，望勿見笑。下面我先說說我的思路。

1. 先構造幾個函式方法用來進行最初的運算（加減乘除）
2. 在運算函式中，先傳入一個字串，將字串利用正則表示式，findall函式生成可以取元素的列表形式，利用返回值，
3. 先進行加法和減法運算，加減法能順利通過驗證，結果無誤
4. 在算式中增加乘法和除法，用if語句進行判斷，如果有乘法和除法，需優先進行計算，通過驗證後
5. 在算式中增加括號，增加括號後，需要進行for迴圈遍歷，如果遍歷的元素中包含括號，則優先處理計算括號裡面的
6. 利用列表臨時儲存返回值，賦給原來的算式，進行遞迴，這樣算式越來越精簡。最終得出結果。

簡單流程圖如下：

以下是實現程式碼：

#!/usr/bin/env python
#-*-coding:utf-8 -*-
 


import re
# 定義函式
def add(x , y): #相加
    return x + y
def subtract(x, y): #相減
    return x - y
def multiply(x, y):  #相乘
    return x * y
def divide(x, y): #相除
    return x / y

temp=[0] #定義一個臨時列表，並且賦值0，用來儲存結果
temp1=[] #定義一個臨時列表，用來臨時儲存列表
def sum2(ret):  #定義一個函式用來進行資料的處理，運算
    for index,mark in enumerate(ret):  #遍歷列表，賦值給mark
 

        if  str(mark).count("(")==1 and str(mark).startswith("("):  #如果mark中包含“（”並且以其開頭
            ret.pop(index)  #將該值（mark），在列表中移除
            mark1=re.findall('^\(\-[0-9.]+|[0-9.]+|[*/+]|[-]',mark)  #將mark元素，再次生成列表
            h = float(re.sub('\(', '', mark1.pop(0)))  #將該表的第一個元素取出，並且將其中所包含的括號替換移除
            mark1.insert(0,h)  #將重新得到的元素，重新插入列表中
            sum2(mark1)  #呼叫遞迴演算法，計算該列表
            ret.insert(index,temp[-1]) #將臨時儲存資料的列表的最後一個元素，插入當前迴圈的索引位置
        elif str(mark).count("(") >= 1:  #如果mark元素中的括號熟練大於等於1
            mark2 = re.findall('\([^()]+\)', mark) #將mark 元素去除最外層括號
            t2=mark2[0]
            mark3 = re.findall('\((.+)\)', mark2[0]) #將mark 元素去除最外層括號
            r1=re.findall('^\(\-[0-9.]+|[0-9.]+|[*/+]|[-]', mark2[0]) #將mark2生成可以計算的列表形式
            h = float(re.sub('\(', '', r1.pop(0)))  #如果r1 包含括號減號則將括號移除
            r1.insert(0, h)
            r2=re.findall('^\(\-[0-9.]+|[0-9.]+|[*/+]|[-]', mark3[0]) #將mark3生成可以計算的列表形式
            mark4=r1 if str(t2).count("(-")==1 else r2  #進行三目運算，判斷mark2（t2）是否包含括號，不同的值賦給mark4
            temp1.clear()  #如果臨時儲存temp1中有資料，則清空
            temp1.extend(ret)  #算式賦值給臨時儲存temp1
            sum2(mark4)   #呼叫遞迴演算法，計算該列表
            q4 = mark.replace(str(mark2[0]), str(temp[-1]))  #將結果值替換該運算位置，賦值給q4
            if str(q4).count("(") >= 1:  #如果字串q4中，包含括號的數量大於等於1
                ret.pop(index)  #將索引位置移除
                ret.insert(index,q4)  #將新得到的字q4
                sum2(ret)  #呼叫遞迴演算法，計算該列表
            else:  #如果不存在括號
                ret.pop(index)  #將索引位置移除
                rr = re.findall('[0-9.]+|[*+\-/]+|\([^()]+\)+|\(.+\)+', q4)  #採用正則重新生成可以可以計算列表形式
                for index11, wor in enumerate(rr):   #迴圈列印 rr中的元素
                    if len(wor) == 2 and wor in "+-*/":  #如果元素wor的長度等於2 並且包含於 符號 "+-*/"，就是同時出現兩個運算子號，其中有一個減號
                        rr.pop(index11)  #移除該索引的元素
                        rr.insert(index11, wor[0])  #將wor元素的第一個運算子插入原來的位置
                        rrr = rr.pop(index11 + 1)  #將下一個索引元素移除
                        rr.insert(index11 + 1, wor[1] + rrr)  #將wor元素的第二個運算子與當前索引的下一個元素合併
                        sum2(rr)  #呼叫遞迴演算法，計算該列表
                        q4=temp[-1]  #將結果值賦值給q4，就是更新q4 （這裡經過計算後，q4 是一個數字了）

                ret.insert(index,q4)  # 將q4 插入到當前運算式的位置
                if len(ret)==3:  #如果運算式的長度為3， 說明可以進行運算
                    sum2(ret) #呼叫遞迴演算法，計算該列表
                elif ret[0]=="-":  #如果運算式的第一個字元為減號，則跳過
                    pass
                elif len(ret)>=3 and q4.isalnum()==False:  #如果運算式的長度等於大於3 並且包含非數字（包含運算子）
                    q5=re.findall("[[0-9.]+|[+\-*/]",q4)  #將q4 生成可以計算的列表形式
                    sum2(q5)  #呼叫遞迴演算法，計算該列表
                    ret.pop(index) #將當前索引元素移除
                    ret.insert(index,temp[-1])  #將計算出的結果值插入當前位置
                    if len(ret)>=3:  #如果算式的長度還大於等於3
                        sum2(ret)  #則繼續遞迴

        #elif  mark == "*" or mark=="/":
        elif str(mark) in "*/":  #如果字串元素中包含運算子 */乘法 和除法
            if (len(ret))>=3:  #如果算式長度大於等於3
                x=float(ret.pop(index-1))  #取出一個元素並移除，轉化為浮點型
                i=ret.pop(index-1)  #取出一個元素並移除 這個是 運算子
                y=ret.pop(index-1) #取出一個元素並移除，轉化為浮點型
                y11=y  #將y賦值給y11
                if "(" in str(y):
                    y12 = re.findall('\([^()]+\)', y11)  #說明該元素中還包含括號，需要繼續運算
                    for index12, gg in enumerate(y12):  #遍歷該元素
                        t2 = y12[0]
                        r1 = re.findall('^\(\-[0-9.]+|[0-9.]+|[*/+]|[-]', y12[0])
                        y14 = re.findall('\((.+)\)', y12[0])
                        h = float(re.sub('\(', '', r1.pop(0)))
                        r1.insert(0, h)
                        r2 = re.findall('^\(\-[0-9.]+|[0-9.]+|[*/+]|[-]', y14[0])
                        # mark4 = str(t2).count("(-")==1 ? r1:r2
                        y13 = r1 if str(t2).count("(-") == 1 else r2  #三目運算

                        sum2(y13)
                        y11 = y11.replace(str(y12[0]), str(temp[-1]))
                        y12.pop(0)
                        y12.append(temp[-1])
                        y15 = re.findall('[0-9.]+|[*+/]|\([^()]+\)+|\(.+\)+|[\-]', y11)
                        sum2(y15)
                        y=temp[-1]  #將最終結果數字賦給y

                y=float(y)  #轉化為浮點型

            if  str(mark)=="*":  #如果元素mark 包含乘號 *
                s=multiply(x,y)  #呼叫乘法計算公式
                ret.insert(index-1,s)  #將結果插入當前索引算式的位置
                temp.append(s)   #將乘積儲存在臨時列表中
                if len(ret)>=3:   #如果算式列表的長度還大於等於3
                    sum2(ret)   #呼叫遞迴演算法，計算該列表
            if str(mark) == "/": #如果元素mark 包含除號 /
                s=divide(x,y)
                temp.append(s)
                ret.insert(index - 1, s)
                if len(ret)>=3:
                    sum2(ret)

    if len(ret)>=3:   #如果算式列表的長度還大於等於3
        x=ret.pop(0)  #取出移除第一個元素
        w2 = re.findall('[0-9.]+|[+\-*/]', str(x))  #將該元素生成可以計算的列表形式
        if str(x)=="-":  #如果x中包含 -號
            x=str(x)+str(ret.pop(0)) #將當前和下一個元素合併 （形成負數）
        if len(w2) >= 4:  #如果x中包含多個算式
            sum2(w2)  #呼叫遞迴演算法，計算該列表
            x = temp[-1]  #將計算的結果賦給x

        x=float(x)
        i=ret.pop(0)
        y=ret.pop(0)
        if str(y)=="-":
            y=y+str(ret.pop(0))
        y =float(y)
        if i in "*/()":
           return
        else:
            if i in "+":  #如果i包含 加號+
                s = add(x, y)
                temp.append(s)
            elif i in "-":  #如果i包含 加號-
                s= subtract(x,y)
                temp.append(s)
        s=temp[-1]  #將得出的結果賦給s
        if len(ret) >= 2:  #算式的長度大於等於2，說明還要繼續計算
            ret.insert(0,s)  #將該結果插入到算式中
            sum2(ret)
    return temp[-2]  #將臨時數值列表中的 最後一個值返回，該值就是最終結果

def  sum():
        arg = input("請輸入算式(只能包含數值，小括號，+-*/):")  #輸入提示
        print("您輸入的算式為：", arg)
        arg = re.sub('\s', '', arg) #將空格全部替換
        arg1= re.match('[(\).+\-*/0-9]+$', arg)  #判斷輸入的是否符合要求

        if arg1: #如果符合要求，則執行下一步
            #print(arg1.group())
            pass
        else:  #如果不符合，重試進入程式
            print("您輸入的包含非法字元,請重新輸入！")
            arg=""
            sum()

        if str(arg).count("(")!=str(arg).count(")"):  #如果輸入的括號對 數量不對，重新輸入
            print("您輸入的括號對數有誤,請重新輸入！")
            arg = ""
            sum()
        arg2="'"+arg+"'"
        #print("計算機結果為：",eval(arg2))
        ret=re.findall('\(.*\)|[0-9.]+|[*/+]|[-]',arg)  #將字串初始成可以計算的列表形式
        j=sum2(ret)  #呼叫函式
        return j

x1 = sum()  #呼叫函式
print("結果：", x1)

完畢！