python 实现计算器

目前实现出了一版，但是精度有问题，分为两个文件
calc.py

import re
import calcFunc

calcStr = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*9/4*2 +10 * 5/14 )) - (-4*3)/ (16-3*2) )"
calcStr = re.sub("\ ","",calcStr)   #   清除输入中的空格
sepStr = ""

res = calcFunc.curveHandleFunc(calcStr)
res = calcFunc.plusMinusFunc(res)
print(res,eval(calcStr))

calcFunc.py

import re

def mulDivFunc(inStr):
    if inStr[0] == "(":
        inStr = inStr[1:-1]
    #   获取字符串中数字列表、符号列表
    digitList = re.findall("[\d\.]+",inStr)
    signList = re.findall("[/\*]",inStr)
    #   如果数字大于等于两个，则需要拆分计算
    if len(digitList) >= 2:
        shuziOne = digitList.pop(0)
        shuziTwo = digitList.pop(0)

        if signList.pop(0) == "*":
            ret = float(shuziOne) * float(shuziTwo)
            digitList.insert(0,"%.2f"%ret)
        else:
            ret = float(shuziOne) / float(shuziTwo)
            digitList.insert(0,"%.2f"%ret)

        newList = list()
        for i in digitList:
            newList.append(i)
            try:
                newList.append(signList.pop(0))
            except:
                pass
        retStr = ""
        if inStr[0] == "-":
            retStr = "-"
            # print("Y")
        retStr = retStr + "".join(newList)
        if len(newList) > 1:
            retStr = mulDivFunc(retStr)
        else:
            pass

        return retStr

    else:
        return inStr

def plusMinusFunc(inStr):
    if inStr[0] == "(":                             #   去除输入字符串的括号
        inStr = inStr[1:-1]
    signList = re.findall("[\-\+]",inStr)               #   获取所有加减符号
    tmpList = re.findall("[\+\-]?[\d\.\*/]+",inStr)     #   获取所有乘除算式

    digitList = list()
    for i in tmpList:
        digitList.append(mulDivFunc(i))

    newList = list()
    for i in digitList:
        newList.append(mulDivFunc(i))

    total = 0
    for i in newList:
        total += float(i)
    return repr(total)

def minusHandleFunc(inStr):

    judgeClass = re.search("[\-\+]{2}",inStr)
    if judgeClass is not None:
        judgeStr = judgeClass.group()
        if judgeStr == "+-":
            minusHandleStr = "-"
        else:
            minusHandleStr = "+"
        outStr = minusHandleStr.join(inStr.split(judgeClass.group()))
        return outStr
    else:
        return inStr

def mulDivHandleFuc(inStr):
    judgeClass = re.search("[\d\.]+[\*/]\-[\d\.]+",inStr)
    if judgeClass is not None:
        judgeStr = judgeClass.group()
        judgeStr = "-" + judgeStr.replace("-","")
        combineList = inStr.split(judgeClass.group())
        outStr = judgeStr.join(combineList)
        outStr = minusHandleFunc(outStr)
        return outStr
    else:
        return inStr

def curveHandleFunc(inStr):
    sepClass = re.search("\([^\(\)]+\)",inStr)      #提取括号内容
    if sepClass is not None:
        sepStr = sepClass.group()                       #提取分隔符
    else:
        sepStr = ""                                 #不存在括号，分隔符为空

    midStr = plusMinusFunc(sepStr)         #计算括号中的算式，并返回结果
    calcList = inStr.split(sepStr)

    retStr = midStr.join(calcList)                  #组装返回字符串

    retStr = minusHandleFunc(retStr)       #剔除算式中 -- +- 符号问题

    retStr = mulDivHandleFuc(retStr)       #剔除算式中 *- /- 符号问题

    if "(" in retStr:
        retStr = curveHandleFunc(retStr)
    return retStr

如下为之前笔记。

'''
 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
'''


import re
calcStr = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"
calcStr = re.sub("\ ","",calcStr)
# print(calcStr)

tmpStr = ""
# tmpStr = re.search("\([\(\)\+\-\*/\d]+",calcStr)
# print(tmpStr.group())


def strExecute(inStr):
    print(inStr)
    outStr = ""
    outStr = re.search("\([\(\)\+\-\*/\d]+",inStr)
    if outStr is not None:
        outStr = strExecute(outStr.group(0)[1:])
        print("pos1",outStr)
        return outStr
    else:
        return inStr

tmpStr = strExecute(calcStr)
print("[Final]:",tmpStr)





'''
 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
'''

import re
calcStr = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"
calcStr = re.sub("\ ","",calcStr)   #   清除输入中的空格
sepStr = ""

def strExecute(inStr):              #查找字符串中的最高优先级算式，并返回字符串
    # print(inStr)
    outStr = ""
    outStr = re.search("\([\(\)\+\-\*/\d]+",inStr)

    if ((outStr is not None) and ("(" in inStr)):
        outStr = strExecute(outStr.group(0)[1:])
        # return outStr
        return re.search("[^\(\)]*",outStr).group(0)
    else:
        # return inStr
        return re.search("[^\(\)]*",inStr).group(0)

sepStr = strExecute(calcStr)
print("[Final]:",sepStr)


'''
 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
'''

import re
#calcStr = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"
#calcStr = re.sub("\ ","",calcStr)   #   清除输入中的空格
#print(calcStr)

calcStr = "-16-3*2+8/3"
calcList = list()

res = re.split("[\+\-]",calcStr)
# print(res)


calcStr = "9*4"
# print(calcStr)

def multiplyDivideFunc(inStr):
    if "*" in inStr:
        print("Multiply in inStr")
        outList = list()
        outList = inStr.split("*")
        # print(float(outList[0])*float(outList[1]))
        return float(outList[0])*float(outList[1])
    elif "/" in inStr:
        print("Divide in inStr")
    else:
        print("Only a digit")
    print(inStr)

multiplyDivideFunc(calcStr)

#2017年2月15日 17:22:56

#\([^\(\)]+\)
#1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) + 3/7