python计算器

最新推荐文章于 2024-09-13 18:11:35 发布
最新推荐文章于 2024-09-13 18:11:35 发布
阅读量111 收藏 1
点赞数
文章标签： python
原文链接：https://yq.aliyun.com/articles/509482
版权

作业需求：

开发一个简单的python计算器：
1、实现加减乘除及拓号优先级解析
2、用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) 等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式(不能调用eval等类似功能偷懒实现)，运算后得出结果，结果必须与真实的计算器所得出的结果一致

作业总结

本次作业做了好几个版本，
    一开始脑子是空白的，越看题目越傻了；
    后来就想的整体写不出来，我留先写乘除加减的函数。结果第一版出来不支持负数，第二版支持负数；
    最后又单独写去括号；
    再将去括号和计算合并，可以实现作业的要求。后来发现代码只是仅仅可以实现作业的需求，和简单的正数类的运算；输入其他中间包含负数之类的就会产生计算错误，越写越没法收场了。。。
    思路重新整理，通过网上查阅各版本思路，回过头来重新整理自己的套路及方法，历尽沧桑呀。
    正确的答案请阅读片段：“作业思路重新整理”

作业思路

主要思路

1、找到最里边的括号
2、把加减和乘除放到函数里，不断的去调取。

具体思路

1、先写出乘除计算的函数，可以进行不包含括号的计算
2、再写出去括号的函数
3、合并代码

计算器流程图

python计算器

乘除函数第一版：
#第一次完成，可以随便 乘 除 加 减 计算，但是不支持负数；

import re
def convert_list(a,arg):
        list1 = []      #转换后的列表
        num = ""
        for i in a:
                if num.isnumeric() and i.isdigit() :
                        list1.pop()
                        num = num + i
                elif i == "-":
                        num = i
                elif i == "." :
                        list1.pop()
                        num = num +i
                elif num[-1:] == "." and i.isdigit():
                        print(num[-1:])
                        list1.pop()
                        num = num+i
                else:
                        num = i
                list1.append(num)
        for i2 in list1:
                arg.append(i2)
        # print(a,"==",arg)
        # return a
        return arg

if __name__ == "__main__":
        # a = "1+10.0*3.0/2-2"
        a = input("please input Calculation formula:<1+3*2-1>:")
        # 转换成列表
        listlist = []
        convert_list(a,listlist)
        print(a,"===",listlist)

        #计算乘除
        while True:
                print(a)
                if "*" in listlist or "/" in listlist:
                        quzhi = re.search("\d+.\d+\*\d+\.\d+|\d+\.\d+\*\d+|\d+\*\d+\.\d+|\d+\*\d+|\d+.\d+\/\d+\.\d+|\d+\.\d+\/\d+|\d+\/\d+\.\d+|\d+\/\d+",a).group()
                        print(type(quzhi))
                        print(quzhi)
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi,quzhi2)
                        print(type(quzhi),type(quzhi2))
                        print(quzhi2)
                        print(quzhi2[2])
                        print("=================")
                        result = float()
                        if "*" in quzhi2:
                                # print(True)
                                print(quzhi2.index("*"))
                                num3 = quzhi2.index("*")
                                list_n = quzhi2[0:num3]
                                print(list_n)
                                x = "".join(list_n)

                                list2_n = quzhi2[num3+1:]
                                y = "".join(list2_n)
                                print(x,y)
                                result = float(x) * float(y)

                                print(result)
                                re1 = listlist.index("*")
                        else:
                                result = float(quzhi2[0]) / float(quzhi2[2])
                        # print(listlist.index(quzhi2[1]))
                        # print(quzhi2)
                                re1 = listlist.index("/")
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.insert(re1-1,str(result))
                        print(listlist)
                        #给变量a 重新赋值
                        a = "".join(listlist)
                        print(a)
                else:
                        break

        while True:
                print(a)
                if "+" in listlist or "-" in listlist:
                        quzhi = re.search("\-\d+\*\d+|\-\d+\/\d+|\-\d+\+\d+|\-\d+\-\d+|\d+.\d+\+\d+\.\d+|\d+\.\d+\+\d+|\d+\+\d+\.\d+|\d+\+\d+|\d+.\d+\-\d+\.\d+|\d+\.\d+\-\d+|\d+\-\d+\.\d+|\d+\-\d+",a).group()
                        # quzhi = re.search(
                        #     "\d+.\d+\+\d+\.\d+|\d+\.\d+\+\d+|\w+\d+\+\d\.\d+|\w+\d\+\d|\d+.\d+\-\d+\.\d+|\d+\.\d+\-\d+|\w+\d+\-\d\.\d+|\w+\d\-\d",
                        #     a).group()
                        print(type(quzhi))
                        print(quzhi)
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi, quzhi2)
                        print(type(quzhi), type(quzhi2))
                        print(quzhi2)
                        print(quzhi2[2])
                        print("=================")
                        result = float()
                        if "+" in quzhi2:
                                # print(True)
                                print(quzhi2.index("+"))
                                num3 = quzhi2.index("+")
                                list_n = quzhi2[0:num3]
                                x = "".join(list_n)

                                list2_n = quzhi2[num3 + 1:]
                                y = "".join(list2_n)
                                print(x, y)
                                result = float(x) + float(y)

                                print(result)
                                re1 = listlist.index("+")
                        else:
                                result = float(quzhi2[0]) - float(quzhi2[2])
                                # print(listlist.index(quzhi2[1]))
                                # print(quzhi2)
                                re1 = listlist.index("-")
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.insert(re1 - 1, str(result))
                        print(listlist)
                        # 给变量a 重新赋值
                        a = "".join(listlist)
                        print(a)
                else:
                        break
乘除函数第二版：
# 乘 除 加 减 后 精简的,优化版本,支持负数；
#修复后支持负数，其实就是： 步骤一、字符串转列表   步骤二、正则匹配

import re
def convert_list(a,arg):
        list1 = []      #转换后的列表
        num = ""
        for i in a:
                if num.isnumeric() and i.isdigit() :
                        list1.pop()
                        num = num + i
                elif i == "." :
                        list1.pop()
                        num = num +i
                elif num[-1:] == "." and i.isdigit():
                        print(num[-1:])
                        list1.pop()
                        num = num+i
                else:
                        num = i
                list1.append(num)
        for i2 in list1:
                arg.append(i2)
        if arg[0] == "-":
                arg.insert(1,arg[0]+arg[1])
                arg.pop(0)
                arg.pop(1)
        print(arg)

        return arg

def ccjj(a,arg):
        # 计算乘除
        while True:
                if "*" in listlist or "/" in listlist:
                        quzhi = re.search(
                                "\-\d+.\d+\*\d+.\d+|\-\d+.\d+\/\d+.\d+|\-\d+\*\d+|\-\d+\/\d+|\d+.\d+\*\d+\.\d+|\d+\.\d+\*\d+|\d+\*\d+\.\d+|\d+\*\d+|\d+.\d+\/\d+\.\d+|\d+\.\d+\/\d+|\d+\/\d+\.\d+|\d+\/\d+",
                                a).group()
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi, quzhi2)
                        result = float()
                        if "*" in quzhi2:
                                num3 = quzhi2.index("*")
                                list_n = quzhi2[0:num3]
                                x = "".join(list_n)
                                list2_n = quzhi2[num3 + 1:]
                                y = "".join(list2_n)
                                result = float(x) * float(y)
                                re1 = listlist.index("*")
                        else:
                                result = float(quzhi2[0]) / float(quzhi2[2])
                                re1 = listlist.index("/")
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.insert(re1 - 1, str(result))
                        # 给变量a 重新赋值
                        a = "".join(listlist)
                else:
                        break

        while True:
                if "+" in listlist or "-" in listlist:
                        quzhi = re.search(
                                "\-\d+.\d+\+\d+.\d+|\-\d+.\d+\-\d+.\d+|\-\d+\+\d+|\-\d+\-\d+|\d+.\d+\+\d+\.\d+|\d+\.\d+\+\d+|\d+\+\d+\.\d+|\d+\+\d+|\d+.\d+\-\d+\.\d+|\d+\.\d+\-\d+|\d+\-\d+\.\d+|\d+\-\d+",a).group()
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi, quzhi2)
                        result = float()
                        if "+" in quzhi2:
                                num3 = quzhi2.index("+")
                                list_n = quzhi2[0:num3]
                                x = "".join(list_n)
                                list2_n = quzhi2[num3 + 1:]
                                y = "".join(list2_n)
                                result = float(x) + float(y)
                                re1 = listlist.index("+")
                        else:
                                num3 = quzhi2.index("-")
                                list_n = quzhi2[0:num3]
                                x = "".join(list_n)
                                list2_n = quzhi2[num3 + 1:]
                                y = "".join(list2_n)
                                result = float(x) - float(y)
                                re1 = listlist.index("-")
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.pop(re1 - 1)
                        listlist.insert(re1 - 1, str(result))

                        # 给变量a 重新赋值
                        a = "".join(listlist)
                else:
                        break
        return  a

if __name__ == "__main__":
        # a = "1+10.0*3.0/2-2"
        while True:
                a = input("please input Calculation formula:<1+3*2-1>:")
                print(a)
                # 转换成列表
                listlist = []
                convert_list(a,listlist)
                print(listlist)
                a = ccjj(a,listlist)

                print("=================\n计算结果为:", a)
                while True:
                        agin = input("\n您还要继续输入吗？<y/n>:")
                        if agin == "y":
                                break
                        elif agin == "n":
                                print("\n 谢谢光临！！")
                                exit()
                        else:
                                print("\n{输入错误，请重新输入！！}\n")
作业版本一：（去括号、加减乘除）
import re,sys
#字符串转列表函数   功能：输入的字符串格式的计算公式转换为列表的形式
def convert_list(a,arg):
        list1 = []      #转换后的列表
        num = ""
        flag = 1
        for i in a:
                if i.isdigit() and num.isnumeric() :
                        list1.pop()
                        num = num + i
                elif num.isdigit() and i == ".":
                        num = num + i
                        flag = 2
                        continue
                elif num in "+-*/" and i == "-":
                        num = i
                        flag = 2
                elif flag == 2 and i.isdigit():
                        list1.pop()
                        num = num + i
                elif flag == 2 and i == ".":
                        list1.pop()
                        num = num + i
                elif flag == 2 and i in "+-*/":
                        num = i
                        flag = 1
                elif flag == 2 and i is not enumerate:
                        list1.append(num)
                        flag = 1
                        num = i
                elif i.isdigit():
                        num = i
                else:
                        num = i
                list1.append(num)
        for i2 in list1:
                arg.append(i2)

        return arg

#计算乘除加减函数   功能：传入计算公式的字符串和列表格式，进行判断计算
def ccjj(a,arg):
        # 计算乘除
        count = 0
        while True:
                if "*" in arg or "/" in arg:
                        quzhi = re.search(
                                "\-\d+\.\d+\*\d+\.\d+|\-\d+\*\d+\.\d+|\d+\*\d+|\-\d+\.\d+\/\d+\.\d+|\-\d+\/\d+\.\d+|\-\d+\.\d+\*\-\d+\.\d+|\-\d+\.\d+\*\-\d+|\-\d+\.\d+\/\-\d+\.\d+|\-\d+\.\d+\/\-\d+|\-\d+\/\-\d+\.\d+|\-\d+\/\-\d+|\d+\.\d+\*\-\d+\.\d+|\d+\.\d+\*\-\d+|\d+\*\-\d+\.\d+|\d+\*\-\d+|\d+\.\d+\/\-\d+\.\d+|\d+\.\d+\/\-\d+|\d+\/\-\d+\.\d+|\d+\/\-\d+|\d+\.\d+\*\d+\.\d+|\d+\.\d+\*\d+|\d+\*\d+\.\d+|\d+\*\d+|\d+\.\d+\/\d+\.\d+|\d+\.\d+\/\d+|\d+\/\d+\.\d+|\d+\/\d+|\d+\.\d+\*\-\d+\.\d+|\d+\.\d+\*\-\d+|\d+\*\-\d+\.\d+|\d+\*\-\d+|\d+\.\d+\/\-\d+\.\d+|\d+\.\d+\/\-\d+|\d+\/\-\d+\.\d+|\d+\/\-\d+",
                                a).group()
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi, quzhi2)
                        print("乘除法取的值：",quzhi,quzhi2)
                        result = float()
                        if "*" in quzhi2:
                                result = float(quzhi2[0]) * float(quzhi2[2])
                                re1 = arg.index("*")
                                # print("乘法完之后：",result)
                        else:
                                result = float(quzhi2[0]) / float(quzhi2[2])
                                re1 = arg.index("/")
                        arg.pop(re1 - 1)
                        arg.pop(re1 - 1)
                        arg.pop(re1 - 1)

                        if float(result) < 0:
                                pass
                        else:
                                if float(quzhi2[2]) < 0 and count !=0:
                                        print("retrun_a:::111", result)
                                        # print(return_a)
                                        return_a = str(-float(result))
                                        print("retrun_a:::222", result)

                                if a[0] == "-" and count ==0 :
                                        print("retrun_a:::11", result)
                                        # print(return_a)
                                        result = str(-float(result))
                                        print("retrun_a:::22", result)

                        arg.insert(re1 - 1, str(result))
                        print("乘除法结果加入到列表：",arg)
                        # 给变量a 重新赋值
                        a = "".join(arg)
                        count +=1
                else:
                        break
        #计算加减
        while True:
                count = 0
                if "+" in arg or "-" in arg:
                        quzhi = ""
                        try:
                                quzhi = re.search(
                                        "\-\d+\.\d+\-\d+\.\d+|\-\d+\.\d+\-\d+|\-\d+\.\d+\+\d+\.\d+|\-\d+\.\d+\+\d+|\-\d+\+\d+\.\d+|\d+\+\d+|\-\d+\.\d+\-\d+\.\d+|\-\d+\-\d+\.\d+|\-\d+\.\d+\+\-\d+\.\d+|\-\d+\.\d+\+\-\d+|\-\d+\.\d+\-\-\d+\.\d+|\-\d+\.\d+\-\-\d+|\-\d+\-\-\d+\.\d+|\-\d+\-\-\d+|\d+\.\d+\+\-\d+\.\d+|\d+\.\d+\+\-\d+|\d+\+\-\d+\.\d+|\d+\+\-\d+|\d+\.\d+\-\-\d+\.\d+|\d+\.\d+\-\-\d+|\d+\-\-\d+\.\d+|\d+\-\-\d+|\d+\.\d+\+\d+\.\d+|\d+\.\d+\+\d+|\d+\+\d+\.\d+|\d+\+\d+|\d+\.\d+\-\d+\.\d+|\d+\.\d+\-\d+|\d+\-\d+\.\d+|\d+\-\d+|\d+\.\d+\+\-\d+\.\d+|\d+\.\d+\+\-\d+|\d+\+\-\d+\.\d+|\d+\+\-\d+|\d+\.\d+\-\-\d+\.\d+|\d+\.\d+\-\-\d+|\d+\-\-\d+\.\d+|\d+\-\-\d+",
                                        a).group()
                        except:
                                pass
                        print("加减法取的值：",quzhi)
                        quzhi2 = []
                        quzhi2 = convert_list(quzhi, quzhi2)
                        # print(quzhi,quzhi2)

                        result = float()
                        if "+" in quzhi2:
                                result = float(quzhi2[0]) + float(quzhi2[2])
                                re1 = arg.index("+")
                                # print(result)
                        else:
                                result = float(quzhi2[0]) - float(quzhi2[2])
                                re1 = arg.index("-")
                                print("加减法得出的结果：",result)
                        arg.pop(re1 - 1)
                        arg.pop(re1 - 1)
                        arg.pop(re1 - 1)

                        if float(result) <= 0:
                                pass
                        else:
                                if float(quzhi2[2]) < 0 and count != 0:
                                        print("retrun_a:::111", result)
                                        # print(return_a)
                                        return_a = str(-float(result))
                                        print("retrun_a:::222", result)

                                if a[0] == "-" and count ==0 :
                                        print("retrun_a:::11", result)
                                        # print(return_a)
                                        result = str(-float(result))
                                        print("retrun_a:::22", result)

                        arg.insert(re1 - 1, str(result))

                     # 给变量a 重新赋值
                        a = "".join(arg)
                        count =+1
                        # print("***:",arg)
                        if len(arg) < 3:
                                break
                else:
                        break

        return  a

#去括号函数  功能：把输入的公式先计算括号里边的内容
def qukuohao(a,arg):
        listlist = []
        convert_list(a,listlist)
        countcount = 1
        while True:
                print("\033[32m[[第%s次计算前：]]\033[0m"%(countcount),a)
                try:
                        index1 = listlist.index(")")
                        # print("查看)的第几个位置：",index1)
                        # print(len(listlist))
                except:
                        pass
                for i in range(index1,-1,-1):
                        try:
                                if listlist[i] == "(":
                                        new_list = listlist[i+1:index1]         #获取括号里的内容
                                        # print("new_list括号里的内容-列表形式---：",new_list)   #打印获取括号里的内容，不包括括号
                                        # print(listlist[i:index1+1])
                                        del_count = len(listlist[i:index1+1])   #获取括号以及括号里的内容的长度，用于后边listlist.pop()
                                        # print("del_count",del_count)          #打印上边的长度

                                        #以下if判断用于 判断括号里是否有计算公式，没有就删除listlist列表里的括号及里边内容并插入计算结果，再进行下次循环；
                                        if len(new_list) < 3:                   #如果new_list的长度小于3，代表括号里边没有计算公式了；
                                                a = "".join(new_list)               #接下来可以直接去掉括号
                                                listlist.pop(index1 - 2)
                                                listlist.pop(index1 - 2)
                                                listlist.pop(index1 - 2)
                                                listlist.insert(index1 - 2,a)       #去掉括号后，把括号里边的内容插入到listlist列表

                                                # print("重新整理后的列表", listlist)
                                                break

                                        new_a = "".join(new_list)       #括号里边的内容转化成字符串，为了运行 convert_list函数做准备
                                        nn_list = []                    #定义括号里的字符串内容转换后 用作的列表
                                        #运行 字符串转成列表函数
                                        convert_list(new_a,nn_list)     #转换括号里的字符串new_a成新的列表nn_list
                                        #运行 乘除加减函数
                                        return_a = ccjj(new_a,nn_list)  #将括号里的字符串形式 和 括号里字符串列表形式 传进去计算；结果return给a

                                        #判断 删除括号以及括号里边的内容的次数，并删除括号以及括号里边的内容
                                        count = 0
                                        for i in range(0,del_count):
                                                # print("----listlist前:", listlist)
                                                if count >= del_count:
                                                        break
                                                else:
                                                        listlist.pop(index1 - (del_count-1))
                                                        count += 1

                                        #将括号里边计算出来的结果 加入到listlist列表中
                                        listlist.insert(index1-(del_count-1),return_a)
                                        a = "".join(listlist)
                                        print("\033[31m[[第%s次计算后：]]\033[0m" % (countcount), a)
                                        countcount += 1     #用于打印去括号计算的次数
                                        break
                        except:
                                pass
                else:
                        break

        #如果计算到最后列表里边没有括号了，直接进行 乘除加减 计算
        a = ccjj(a,listlist)
        # print("\033[34m最后的计算结果是：%s\033[0m"%a)
        print("\033[31m[[第%s次计算后：]]\033[0m" % (countcount), a)
        return a

if __name__ == "__main__":
        # a = "1-(5*2-5*3/2)+10"
        count = 0
        while True:
                msg = "------------------------------------------------------------------------------\n" \
                            "请输入计算公式:\n" \
                            "如①：<1+3*2-1>\n" \
                            "如②：1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))\n" \
                            "------------------------------------------------------------------------------"
                print(msg)
                a = input("\033[42m please input Calculation formula:\033[0m")
                a = a.replace(" ", "")  # 去空格
                if count < 3:
                        # 转换成列表
                        listlist = []
                        if "(" in a:
                                #去括号
                                a = qukuohao(a,listlist)
                        else:
                                convert_list(a, listlist)
                                # print(listlist)
                                # print(a)
                                a = ccjj(a, listlist)

                        p = len(a) + 20

                        for i in range(p):
                                sys.stdout.write("#")
                                sys.stdout.flush()
                                # time.sleep(0.1)
                        sys.stdout.write("\n")

                        print("\033[34m最后的计算结果是：%s\033[0m"%a)

                        for i in range(p):
                                sys.stdout.write("#")
                                sys.stdout.flush()
                                # time.sleep(0.1)
                        sys.stdout.write("\n")

                elif count > 2 :
                        agin = input("\n您还要继续输入吗？<y/n>:")
                        if agin == "y":
                                break
                        elif agin == "n":
                                print("\n 谢谢光临！！")
                                exit()
                        else:
                                print("\n{输入错误，请重新输入！！}\n")

存在问题

只支持作业上的计算和简单的加减计算；
     1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))
但是计算公式中间有负数之类的就会计算错误：
     例如：1-(5*2-5*3/2)+10   计算结果正确是8.5

作业思路重新整理

    1、加减乘除正则匹配重新整理；
    2、计算结果替换 用上x.replace(source,dest) ；
    3、字符串转列表循环修复；
    4、去括号
                获取括号里边的内容用正则匹配，而不是for循环；
                计算结果替换 用上x.replace(source,dest) ；
    5、用户输入公式后，先判断输入的是否包含非公式的不规则字符，有则提示“输入错误！”；
    6、用户输入公式后，判断输入的字符串是否包含计算公式，不包含则不进入计算函数；
    7、关键问题：将所有的加和减，都以加的形式计算；
                例如：9-2*5    再匹配乘除计算的时候先是：-2*5；然后再9+-10

思路重新整理之前的问题：
    1、正则匹配没有精简，也没有最佳匹配；
    2、字符串转列表存在缺陷；
    3、可能出现的公式形式没有想的周全，有些偏面；
    4、知识点没能够合理运用，字符串替换；
    5、最大问题是没有想清楚有负数的各种形式时候如何计算；
最终作业版本
#!/bin/bash/env python#_*_ coding:utf-8 _*_#python version: 3.x#author: 506554897import#字符串转列表函数def convert_list(a,arg):#转换后的列表""10forinifandelifand"."2continueelifin"+-*/"and"-"2elif2andelif2and"."elif2andin"+-*/"1elif2andisnot1elif0and"+"continueelifelse1forin# print("转成列表后的字符串和列表：",a,arg)return#加减乘除函数def jjcc(a):#乘除循环whileTrueif"*"inor"/"in"\+?\-?\d+\.?\d*[*|/]\-?\d+\.?\d*"#用于保存正则取值后的列表# print("乘除取到的值：",quzhi,type(quzhi),type(quzhi2),quzhi2)if1"*"02elif1"/"02if0#用于结果是 +8 类似的，给取绝对值，去掉+ ；"+"else# print("乘除替换后的值：",a)elsebreak#加减循环whileTrue#判断字符串是否还有计算公式的存在#判断字符串 里边是否已经没有 加减乘除 的公式 的列表if3#如果judge列表元素的长度小于3，代表已经没有计算公式了if0#用于结果是 +8 类似的，给取绝对值，去掉+ ；# print("最后的结果：",a)breakif"+"inor"-"in"\+?\-?\d+\.?\d*[+|-]\-?\d+\.?\d*"# print("加减取的值：",quzhi,type(quzhi),quzhi2,type(quzhi2))if1"+"02elif1"-"02# print("加减后的值：",a)elsebreakreturn#去括号函数def remove_parenthesis(a):#去括号循环1# 用于计算进行了几次去括号whileTrueif")"in"\033[32m[[第%s次括号计算前：]]\033[0m""\([^()]+\)"# print(quzhi)"()"#去掉字符串里边的"()"# print("去括号取到的值：",quzhi2)#运行加减乘除函数，进行计算#将计算结果替换前边正则匹配的字符串# print("<<去括号替换后的结果：>>",a)elsebreak"\033[31m[[第%s次括号计算后：]]\033[0m"1# 用于打印去括号计算的次数returnif"__main__"# a = "1+10.0*3.0/2-2"0#计算用户输入的公式次数whileTrue"------------------------------------------------------------------------------\n""\033[31m输入计算公式例子:\n\033[0m""如①：1+3*2-1\n""如②：1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))\n""------------------------------------------------------------------------------""\033[47m please input Calculation formula:\033[0m"" """# 去空格#判断是否输入计算公式以外的字符，例如中文、字母try"[^+|\-|*|/|(|)|\d]+"ifisnotNone# 如果输入字符串包含不规则就提示输入错误！！"\033[41m输入错误！！！\033[0m"continueexceptpass#判断输入公式的次数if3# 检查输入的是否是公式# 判断字符串 里边有没有 加减乘除 的公式 的列表if3#如果judge的元素小于3，代表输入的字符串没有计算公司if00#如果输入的+8 进行绝对值把 + 去掉"\033[31m输入的没有计算公式！\033[0m"# 如果输入的字符串有公式else#去括号"\033[32m<<去完括号后的结果:>>\033[0m"#统计“最后的计算结果是：XX”字符串的长度；“最后的计算结果是：”的长度是20 + a的长度20#根据p的长度打印 n个#forin"#"# time.sleep(0.1)"\n"#打印计算结果"\033[34m最后的计算结果是：%s\033[0m"# 根据p的长度打印 n个#forin"#"# time.sleep(0.1)"\n\n"#如果输入公式次数大于3次提示是否继续输入elif2"\n您还要继续输入吗？<y/n>:"if"y"breakelif"n""\n 谢谢光临！！"else"\n{输入错误，请重新输入！！}\n"，如需转载请自行联系原作者
weixin_34161032
关注
[flex&bison]制作计算器——支持括号和负数
tankloverainbow的博客
02-05 1254
功能 1. 只支持整数计算 2. 支持括号 3. 支持负数 文件内容 flex文件 %{ #include "calc.tab.h" %} %% [1-9][0-9]* { yylval.int_val = atoi(yytext); printf("&lt;flex::num&gt;%d\n",yylval.int_val);...
python简单计算器
aiguan1864的专栏
02-04 115
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time : 2018-01-15 20:40# @Author : hhj# @Site :一、计算器一import redef operator_update(formula): # 对formula公式进行 去除空字符，更新运算符处理 formula = formula.rep...
带括号 非负数 的计算器
勿忘初心
09-14 672
op数组用来存储处理后输入的表达式，经过处理，不带空格，viisit数组为1的时候，对应的op数组位置是运算符，否则是整数。然后就是比较运算符的优先级了，opnd是数字栈，optr是运算符栈。optr栈底先存一个‘#’，用数组存储一下运算符的优先级。具体代码： #include #include #include #include #include #include #include
用python的正则表达式实现简单的计算器功能
weixin_30266829的博客
06-28 101
#!/usr/bin/env python # -*- coding:utf-8 -*- import sys import re def welcome_func(): """ 输入判断 :param expression: 表达式 :return: 返回有效表达式 """ welcome_str = "超级计算器" print(welcome_str...
[Python实战]使用栈实现简易计算器
Python高效编程
08-13 805
我们这次实现的命令行计算器，支持加减乘除、括号、浮点数、负数，以及查看历史和退出功能。主要的思路：read - parse - print - loop。read 阶段是...
suode.zip_calculator python_python 计算器_python计算器
09-22
首先，让我们来理解标题"suode.zip_calculator python_python 计算器_python计算器"。这表明我们有一个名为“suode.zip”的压缩文件，其中包含了一个Python编写的个人所得税计算器程序。文件“suode.py”是这个...
Python计算器
09-25
在这个"Python计算器"项目中，我们通常会实现基本的算术运算，如加法、减法、乘法和除法，可能还会包括一些更高级的功能，比如求平方根、对数、指数等。 1. **基本Python语法** Python是一种解释型、面向对象的...
calculator.rar_python 计算器_python计算器_计算器 python
07-14
用python实现简易计算器，包括+，-，*，/及一些扩展运算，是联系python的GUI编程的很好的练手题目。
经典python基础小项目练习
weixin_30700977的博客
05-07 378
''' 3.升级题：实现一个整数加法计算器（多个数相加）： 如：content = input("请输入内容:") 用户输入：5+9+6 +12+ 13，然后进行分割再进行计算。 ''' ''' content = input("请输入内容:") # print(content) listvar = content.split("+") # print(listvar) r...
python基础： day4作业计算器
weixin_34367257的博客
02-18 109
作业：计算器开发 实现加减乘除及拓号优先级解析 用户输入1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式，运算后得出结果，结果必须与真实的计算器所得出的结果一致 一、说明： 有一点bug就...
python代码计算1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7/3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))
qq_44309711的博客
06-02 857
exp= '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7/3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))' print(eval(exp)) import re #按照加减乘除找最左边的 def arithmetic(s): if re.search(r"\(\s{0,}-", s): ret=re.search(r"(-?\d+(?:\.\d+)?)\s{0,}([-+*/])\s{0,}(-?..
通过Python实现简单的计算器
马赛克的博客
01-12 2490
    目录 1.计算器需求 2.初步实现思路： 3.再次分析思路 4.所需知识点 5.代码 6.总结 1.计算器需求 实现加减乘除及拓号优先级解析 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须自己  ...
逆波兰计算器，实现对负数的支持（TCPL,练习4-3）
hanyi0000的专栏
08-30 2536
关于逆波兰计算，（5-3）*2 表示为 5 3 - 2 * 这样的表示中，是不支持负数的，因为所有出现的“-”都会被认为是“减号”，例如5*（-3），逆波兰表示为5 -3 * ，按照规则，遇到“-”时，取栈顶的两位，便会报错（只有一个5）。 因此，为了支持负数，可以引进一个符号位，标记可能出现的负数。尝试引进左括号“（”，于是上式便可以写为 5 （-3 * 作为标识符，为了延展通用性，即便是正
一个可以计算表达式的计算器
RICH_BABA的专栏
04-16 1251
    一个可以计算表达式的计算器，还带了闹钟功能，当然做的实在太业余（目录功能还没加完），不会MFC，用win32的API函数凑出了的。    完全展开： 精简模式： 记录窗口： 消息窗口： 闹钟：   
作业1开发一个简单的python计算器
weixin_34327223的博客
09-10 614
开发一个简单的python计算器 实现加减乘除及拓号优先级解析 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式(不能调用eval等类似功能偷懒实现)，运算后得出结果，结果必须与真实的计算器所得...
简单计算器（不含括号）
xxidaojia的博客
04-18 1079
做一个简单计算器，包括加减乘除四则混合运算，不加括号！！！输入一个数字指定本次计算多少算式n，接下来每输入一个算式回车计算。代码如下：#include &lt;stdio.h&gt; int main() { int n; double a[100]; while(scanf("%d",&amp;n)!=EOF) { while(n--) { doubl...
Python世界：力扣29题两数相除算法实践
最新发布
来知晓的博客
09-13 182
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 450
蒙特卡罗——布丰实验
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值