计算器<代码>

 import re
 l_no = "-4.0*-4+((-1-8.0*2*-1)-(-9.456/1.57))/8+-8*7"
 true_tr = "-4.0*-4+((-1-8.0*2*-1)-(-9.456/1.57))/8+-8*7"
 trunswer = eval(true_tr)
 print(trunswer)
 l = re.sub(" +","",l_no)  # 替换 没有+号也能实现  有第四个元素 为替换几次
 l_list = list(l)          # 还有一个subn方法 会返回一个替换几次的数字
 def check_w(formula):                     #  check函数
     formula=re.sub("--","+",formula)
     formula=re.sub("-\+|\+-","+",formula)    # 管道符号|的意思是or 反斜杠\ 消除特殊意义
     a = re.findall("[a-z]|[A-Z]",formula)    # 中括号会消除特殊字符 并且都是or关系
     b = re.findall("\(\)",formula)        # 找空括号
     if a or b:
         print("存在字母空括号")
         exit()
     return formula
 l_no = check_w(l_no)
 s = l_no
 def left_parenthesis(formula):         # find the left parenthesis  --
     a = re.search("\(", formula)
     if a == None:                      # 有一种个简单方法“\([^()]+\)” 中括号消除特殊意思
         return None                    # 但是除了\ ^ -三个 “\(（[^()]+）\)”会匹配括号内容
     b = a.span()                       # 因为findall是优先匹配括号内容
     return b[1]
 def right_parenthesis(formula):          # find the right parenthesis --
     a = re.search("\)", formula)
     if a == None:
         return None
     b = a.span()
     return b[1]
 def code_muldiv(numcc):                # function for multiplication and division
     result = []                        # 这是一种算法 所有factor制成列表 所有mathematical symbol
     for i in numcc:                    # （-+或者*/）制成一个列表 之后利用列表有顺序来进行计算
         jishufuhao = 0                 # 正好适合8*-8这种形式
         jishushu = 1
         fuhao2 = []
         num = []
         fuhao2 = re.findall("\*|/",i)
         num = re.split("[*/]",i)             # 将所有因数（除数）整理成一个列表
         flag2 =True
         while flag2:
             if fuhao2[jishufuhao] == "*":
                 ga = float(num[jishushu-1]) * float(num[jishushu])
                 num[jishushu] = ga
                 jishushu+=1
                 jishufuhao+=1
             elif fuhao2[jishufuhao] == "/":
                 ha = float(num[jishushu - 1]) / float(num[jishushu])
                 num[jishushu] = ha
                 jishushu += 1
                 jishufuhao += 1
             if jishufuhao+1 > len(fuhao2):
                 flag2 = False
         result.append(num[jishushu-1])
     return result
 def code_addsub(numcc):       # function for addition and subtraction
     result = []
     for i in numcc:
         jishufuhao = 0
         jishushu = 1
         fuhao2 = []
         num = []
         i = re.sub("--","+",i)
         i = re.sub("\+-|-\+","-",i)
         i = re.sub("^\+","",i)
         a = re.findall("^-\d+\.?\d*",i)    ### 如果formula为 -9+8 ，这个函数的功能
         if a == []:                        ### 就是将其转换为  0+8-9 这样便将minus
             pass                           ### 转化为无符号式子
         else:                              ###
             i = re.sub(a[0],"",i,1)       ###
             i = "".join([i,a[0]])          ###
         fuhao2 = re.findall("\+|-",i)
         num = re.split("[+-]",i)
         if fuhao2 ==[]:
             return numcc
         flag2 = True
         while flag2:
             if fuhao2[jishufuhao] == "+":
                 ga = float(num[jishushu-1]) + float(num[jishushu])
                 num[jishushu] = ga
                 jishushu+=1
                 jishufuhao+=1
             elif fuhao2[jishufuhao] == "-":
                 ha = float(num[jishushu - 1]) - float(num[jishushu])
                 num[jishushu] = ha
                 jishushu += 1
                 jishufuhao += 1
             if jishufuhao+1 > len(fuhao2):
                 flag2 = False
         result.append(num[jishushu-1])
     return result
 def exchange_l(formula):           # for calculating mul div
     flag4 = True
     while flag4:
         need_md = re.findall("\d+\.?\d*[*/]-?\d+\.?\d*",formula)
         if need_md == []:  # 上边这个正则 是匹配乘除并且两边是3.9这样的数字
             break
         e = need_md
         k = code_muldiv(e)
         out_s = formula.replace(str(need_md[0]),str(k[0]))
         formula =out_s
     return formula
 flag2 = True
 while flag2:
     flag = True
     a = 0
     y_y=right_parenthesis(s)
     if y_y == None:                       # 判断 没有括号时，直接计算
         formula_jj = exchange_l(l)
         final_result = code_addsub([formula_jj])
         l = l.replace(l, str(final_result[0]), 1)
         s = l
         print("result:",s)
         break
     else:
         y = right_parenthesis(s) - 1
     while flag:                              # 多次寻找左括号 并且切片后再寻找
         position_psis = left_parenthesis(s)
         if position_psis == None:
             position_psis = 0
             break
         s= s[position_psis:]             # 将找到的左括号后面的字符串切片
         a += position_psis               # 记录下序列号
         if a > y:                        # 若是左括号序列号比右括号大 则停止寻找
             flag = False
     a = a - position_psis
     need_l = l[a:y]                      # 需要处理的括号内容
     ex_input = l[a - 1:y + 1]
     need_l =str(need_l)   # 3+2-3
     formula_jj = exchange_l(need_l)      # 进行乘除处理
     final_result = code_addsub([formula_jj]) # 进行加减处理
     l = l.replace(ex_input, str(final_result[0]), 1) # 用结果替换掉字符串
     s = l                                            # 赋值再次循环用

import re
l_no = "-4.0*-4+((-1-8.0*2*-1)-(-9.456/1.57))/8+-8*7"
true_tr = "-4.0*-4+((-1-8.0*2*-1)-(-9.456/1.57))/8+-8*7"
trunswer = eval(true_tr)
print(trunswer)
l = re.sub(" +","",l_no)  # 替换 没有+号也能实现  有第四个元素 为替换几次
l_list = list(l)          # 还有一个subn方法 会返回一个替换几次的数字
def check_w(formula):                     #  check函数
formula=re.sub("--","+",formula)
    formula=re.sub("-\+|\+-","+",formula)    # 管道符号|的意思是or 反斜杠\ 消除特殊意义
a = re.findall("[a-z]|[A-Z]",formula)    # 中括号会消除特殊字符 并且都是or关系
b = re.findall("\(\)",formula)        # 找空括号
if a or b:
print("存在字母空括号")
        exit()
    return formula
l_no = check_w(l_no)
s = l_no
def left_parenthesis(formula):         # find the left parenthesis  --
a = re.search("\(", formula)
    if a == None:                      # 有一种个简单方法“\([^()]+\)” 中括号消除特殊意思
return None                    # 但是除了\ ^ -三个 “\(（[^()]+）\)”会匹配括号内容
b = a.span()                       # 因为findall是优先匹配括号内容
return b[]
def right_parenthesis(formula):          # find the right parenthesis --
a = re.search("\)", formula)
    if a == None:
return None
b = a.span()
    return b[]
def code_muldiv(numcc):                # function for multiplication and division
result = []                        # 这是一种算法 所有factor制成列表 所有mathematical symbol
for i in numcc:                    # （-+或者*/）制成一个列表 之后利用列表有顺序来进行计算
jishufuhao = 0                 # 正好适合8*-8这种形式
jishushu = 1
fuhao2 = []
        num = []
        fuhao2 = re.findall("\*|/",i)
        num = re.split("[*/]",i)             # 将所有因数（除数）整理成一个列表
flag2 =True
        while flag2:
if fuhao2[jishufuhao] == "*":
ga = float(num[jishushu-]) * float(num[jishushu])
                num[jishushu] = ga
                jishushu+=1
jishufuhao+=1
elif fuhao2[jishufuhao] == "/":
ha = float(num[jishushu - ]) / float(num[jishushu])
                num[jishushu] = ha
                jishushu += 1
jishufuhao += 1
if jishufuhao+1 > len(fuhao2):
flag2 = False
result.append(num[jishushu-])
    return result
def code_addsub(numcc):       # function for addition and subtraction
result = []
    for i in numcc:
jishufuhao = 0
jishushu = 1
fuhao2 = []
        num = []
        i = re.sub("--","+",i)
        i = re.sub("\+-|-\+","-",i)
        i = re.sub("^\+","",i)
        a = re.findall("^-\d+\.?\d*",i)    ### 如果formula为 -9+8 ，这个函数的功能
if a == []:                        ### 就是将其转换为  0+8-9 这样便将minus
pass                           ### 转化为无符号式子
else:                              ###
i = re.sub(a[],"0",i,)       ###
i = "".join([i,a[]])          ###
fuhao2 = re.findall("\+|-",i)
        num = re.split("[+-]",i)
        if fuhao2 ==[]:
return numcc
flag2 = True
        while flag2:
if fuhao2[jishufuhao] == "+":
ga = float(num[jishushu-]) + float(num[jishushu])
                num[jishushu] = ga
                jishushu+=1
jishufuhao+=1
elif fuhao2[jishufuhao] == "-":
ha = float(num[jishushu - ]) - float(num[jishushu])
                num[jishushu] = ha
                jishushu += 1
jishufuhao += 1
if jishufuhao+1 > len(fuhao2):
flag2 = False
result.append(num[jishushu-])
    return result
def exchange_l(formula):           # for calculating mul div
flag4 = True
    while flag4:
need_md = re.findall("\d+\.?\d*[*/]-?\d+\.?\d*",formula)
        if need_md == []:  # 上边这个正则 是匹配乘除并且两边是3.9这样的数字
break
e = need_md
        k = code_muldiv(e)
        out_s = formula.replace(str(need_md[]),str(k[]))
        formula =out_s
    return formula
flag2 = True
while flag2:
flag = True
a = 0
y_y=right_parenthesis(s)
    if y_y == None:                       # 判断 没有括号时，直接计算
formula_jj = exchange_l(l)
        final_result = code_addsub([formula_jj])
        l = l.replace(l, str(final_result[]), )
        s = l
        print("result:",s)
        break
    else:
y = right_parenthesis(s) - 1
while flag:                              # 多次寻找左括号 并且切片后再寻找
position_psis = left_parenthesis(s)
        if position_psis == None:
position_psis = 0
break
s= s[position_psis:]             # 将找到的左括号后面的字符串切片
a += position_psis               # 记录下序列号
if a > y:                        # 若是左括号序列号比右括号大 则停止寻找
flag = False
a = a - position_psis
    need_l = l[a:y]                      # 需要处理的括号内容
ex_input = l[a - :y + ]
    need_l =str(need_l)   # 3+2-3
formula_jj = exchange_l(need_l)      # 进行乘除处理
final_result = code_addsub([formula_jj]) # 进行加减处理
l = l.replace(ex_input, str(final_result[]), ) # 用结果替换掉字符串
s = l                                            # 赋值再次循环用