一、功能目标
用户输入一个类似  1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))  这样的表达式，假设表达式里面除了包含空格、'+'、'-'、'*'、'/'和括号再无其他特殊符号，然后自己动手写代码解析其中的表达式，实现加减乘除，最后得出的结果与真实的计算机所算的结果必须一致。
二、解题思路
1、为了分开运算符和数字，因此把输入的字符串格式转换为 列表的格式进行处理，这样子就可以按位进行 处理了
2、实现功能的核心点在于括号、乘除、加减的优先级排序，因此我们先想办法一层一层的去括号，即从最里层的括号开始计算，然后去掉第一层括号，然后一直继续这个 过程，最后得到一个没有括号的列表，再进行计算得出结果
3、去括号方式：最内层的括号内的表达式就可以当做一个无括号表达式，通过先 运算出乘除，再运算出加减得出整个括号内的值，用这个结果值整体替换括号内的内容即实现了去一层括号，然后通过递归去除所有的括号
4、去除乘除号方式：见 remove_multiplication_division(eq) 函数部分
5、去除加减号 方式：见 remove_plus_minus(eq) 函数部分
三、函数说明
1、主函数
def caculator(eq):
format_list = eq_format(eq) # 把字符串变成格式化列表形式
s_eq = simplify(format_list) # 去括号，得到无括号的一个格式化列表
ans = calculate(s_eq)    # 计算最终结果
if len(ans) == 2:      # 判断最终结果为正数还是负数
ans = -float(ans[1])
else:
ans = float(ans[0])
return ans
2、eq_format( )函数
def eq_format(eq):
'''
:param eq: 输入的算式字符串
:return: 格式化以后的列表，如['60','+','7','*','8']
'''
format_list = re.findall('[\d\.]+|\(|\+|\-|\*|\/|\)',eq)
return format_list
2.1 这个函数的作用是把输入的算式通过re模块，用正则表达式把算术符号和数字分开。
2.2  [\d\.]+ | \( | \+ | \- | \* | \/ | \)意思：按管道符号 | (| 表示 或 的意思)可分为几部分，[\d\.]+  是指匹配数字或小数点一次或多次，\(是指左括号，\+ 是指 加号，\- 是指减号，\* 是指乘号，\/ 是指除号， \) 是指右括号，整个正则表达式会把字符串变成类似['(','6','*','5','-''7',')' ]这样子的格式列表
3、simplify( ) 函数
def simplify(format_list):
'''
:param format_list: 输入的算式格式化列表如['60','+','7','*','8']
:return: 通过递归去括号，返回简化后的列表
'''
bracket = 0   # 用于存放左括号在格式化列表中的索引
count = 0
for i in format_list:
if i == '(':
bracket = count
elif i == ')':
temp = format_list[bracket + 1 : count]
# print(temp)
new_temp = calculate(temp)
format_list = format_list[:bracket] + new_temp + format_list[count+1:]
format_list = change(format_list,bracket)   # 解决去括号后会出现的-- +- 问题
return simplify(format_list)      # 递归去括号
count = count + 1
return format_list           # 当递归到最后一层的时候，不再有括号，因此返回列表
3.1 这个函数的作用是：把输入的带有括号的格式化列表，用递归的方式去除括号，每一次递归去一个括号， 直到没有括号则返回去完括号的格式化列表
3.2 找到最内层括号的方法：遍历列表，如果遇到左括号，则把当前左括号的索引赋值给参数bracket，直到遇到第一个右括号，此时的索引与bracket中间的元素即为最内层括号的元素，用切片的方式提取出来，通过 calculate() 函数计算出值，然后用计算结果去替换掉此时左括号到第一个右括号的元素，此时去除第一层括号，然后进入递归，不断递归直至去除所有括号
3.3 可能遇到的问题：
首先是不要用index的方式去取当前左括号的索引，因为列表的index方法返回的一直都是第一个左括号的索引，而不是当前左括号的索引，会导致出错。因此我在函数内用参数 count 进行计数当前索引值。
然后是用计算得出的值来替换掉第一层括号部分后，有可能会出现 ‘+-' ，‘ - -'的情况，要记得处理，我的函数中写了一个change() 函数进行处理
4、caculate()函数
def calculate(s_eq):
'''
:param s_eq: 不带括号的格式化列表
:return: 计算结果
'''
if '*' or '/' in s_eq:
s_eq = remove_multiplication_division(s_eq)
if '+' or '-' in s_eq:
s_eq = remove_plus_minus(s_eq)
return s_eq
这个函数的作用是输入不带括号的格式化列表， 输出计算结果，然后返回结果列表
思路是先算乘除：remove_multiplication_division()函数，然后再从头到尾计算加减法：remove_plus_minus( )函数
5、remove_multiplication_division()函数
def remove_multiplication_division(eq):
'''
:param eq: 带有乘除号的格式化列表
:return: 去除了乘除号的格式化列表
'''
count = 0
for i in eq:
if i == '*':
if eq[count+1] != '-':
eq[count-1] = float(eq[count-1]) * float(eq[count+1])
del(eq[count])
del(eq[count])
elif eq[count+1] == '-':
eq[count] = float(eq[count-1]) * float(eq[count+2])
eq[count-1] = '-'
del(eq[count+1])
del(eq[count+1])
eq = change(eq,count-1)
return remove_multiplication_division(eq)
elif i == '/':
if eq[count+1] != '-':
eq[count-1] = float(eq[count-1]) / float(eq[count+1])
del(eq[count])
del(eq[count])
elif eq[count+1] == '-':
eq[count] = float(eq[count-1]) / float(eq[count+2])
eq[count-1] = '-'
del(eq[count+1])
del(eq[count+1])
eq = change(eq,count-1)
return remove_multiplication_division(eq)
count = count + 1
return eq
这个函数的作用是计算乘除，去乘除号。方法也是递归的方法，每次处理完一个乘号或者除号都可能出现符号问题，记得处理后再进入下一次递归
6、remove_plus_minus( )函数
def remove_plus_minus(eq):
'''
:param eq: 只带有加减号的格式化列表
:return: 计算出整个列表的结果
'''
count = 0
if eq[0] != '-':
sum = float(eq[0])
else:
sum = 0.0
for i in eq:
if i == '-':
sum = sum - float(eq[count+1])
elif i == '+':
sum = sum + float(eq[count+1])
count = count + 1
if sum >= 0:
eq = [str(sum)]
else:
eq = ['-',str(-sum)]
return eq
这个函数输入一个只有加减号的格式化列表，然后从头到尾的计算，得出最终结果，返回最终结果(结果形式也是列表)
7、change()函数
def change(eq,count):
'''
:param eq: 刚去完括号或者乘除后的格式化列表
:param count: 发生变化的元素的索引
:return: 返回一个不存在 '+-' ,'--'类的格式化列表
'''
if eq[count] == '-':
if eq[count-1] == '-':
eq[count-1] = '+'
del eq[count]
elif eq[count-1] == '+':
eq[count-1] = '-'
del eq[count]
return eq
这个函数的作用是解决符号输入两个问题。输入参数1：刚去完括号的或者刚 计算完乘除的 格式化列表，输入参数2： 列表元素发生变化的索引(如去括号时，这个索引则为去括号前列表的最内层左括号的索引)，输出结果是一个处理完符号问题或者什么都不做直接返回的列表
四、完整代码
需要的小伙伴，请关注微信公众号: Python客栈, 或者扫描下方公众号二维码，回复关键字：计算器, 即可免费无套路获取
↑关注上方公众号回复计算器即可↑
程序运行结果

我正在攻读GCSE的计算课程，我们的控制性评估任务之一是创建一个带有图形用户界面的计算器。
我可以在没有图形用户界面的情况下编程一个简单的计算器，但是我不知道如何使用图形用户界面来完成它。
下面是我从teampython.wordpress.com得到的一段代码，我很模糊地理解了它，但是如果有人能向我解释每一个步骤，它会非常有用。# calc.py - a Python calculator
from tkinter import *
class Calc():
def __init__(self):
self.total = 0
self.current = ""
self.new_num = True
self.op_pending = False
self.op = ""
self.eq = False
def num_press(self, num):
self.eq = False
temp = text_box.get()
temp2 = str(num)
if self.new_num:
self.current = temp2
self.new_num = False
else:
if temp2 == '.':
if temp2 in temp:
return
self.current = temp + temp2
self.display(self.current)
def calc_total(self):
self.eq = True
self.current = float(self.current)
if self.op_pending == True:
self.do_sum()
else:
self.total = float(text_box.get())
def display(self, value):
text_box.delete(0, END)
text_box.insert(0, value)
def do_sum(self):
if self.op == "add":
self.total += self.current
if self.op == "minus":
self.total -= self.current
if self.op == "times":
self.total *= self.current
if self.op == "divide":
self.total /= self.current
self.new_num = True
self.op_pending = False
self.display(self.total)
def operation(self, op):
self.current = float(self.current)
if self.op_pending:
self.do_sum()
elif not self.eq:
self.total = self.current
self.new_num = True
self.op_pending = True
self.op = op
self.eq = False
def cancel(self):
self.eq = False
self.current = "0"
self.display(0)
self.new_num = True
def all_cancel(self):
self.cancel()
self.total = 0
def sign(self):
self.eq = False
self.current = -(float(text_box.get()))
self.display(self.current)
sum1 = Calc()
root = Tk()
calc = Frame(root)
calc.grid()
root.title("Calculator")
text_box = Entry(calc, justify=RIGHT)
text_box.grid(row = 0, column = 0, columnspan = 3, pady = 5)
text_box.insert(0, "0")
numbers = "789456123"
i = 0
bttn = []
for j in range(1,4):
for k in range(3):
bttn.append(Button(calc, text = numbers[i]))
bttn[i].grid(row = j, column = k, pady = 5)
bttn[i]["command"] = lambda x = numbers[i]: sum1.num_press(x)
i += 1
bttn_0 = Button(calc, text = "0")
bttn_0["command"] = lambda: sum1.num_press(0)
bttn_0.grid(row = 4, column = 1, pady = 5)
bttn_div = Button(calc, text = chr(247))
bttn_div["command"] = lambda: sum1.operation("divide")
bttn_div.grid(row = 1, column = 3, pady = 5)
bttn_mult = Button(calc, text = "x")
bttn_mult["command"] = lambda: sum1.operation("times")
bttn_mult.grid(row = 2, column = 3, pady = 5)
minus = Button(calc, text = "-")
minus["command"] = lambda: sum1.operation("minus")
minus.grid(row = 3, column = 3, pady = 5)
point = Button(calc, text = ".")
point["command"] = lambda: sum1.num_press(".")
point.grid(row = 4, column = 0, pady = 5)
add = Button(calc, text = "+")
add["command"] = lambda: sum1.operation("add")
add.grid(row = 4, column = 3, pady = 5)
neg= Button(calc, text = "+/-")
neg["command"] = sum1.sign
neg.grid(row = 5, column = 0, pady = 5)
clear = Button(calc, text = "C")
clear["command"] = sum1.cancel
clear.grid(row = 5, column = 1, pady = 5)
all_clear = Button(calc, text = "AC")
all_clear["command"] = sum1.all_cancel
all_clear.grid(row = 5, column = 2, pady = 5)
equals = Button(calc, text = "=")
equals["command"] = sum1.calc_total
equals.grid(row = 5, column = 3, pady = 5)
root.mainloop()

分析：

1.设计好界面

2.必须有两个textbox来输出结果和算术式

3.具备基本的数字和运算符

4.所有的按钮都有对应的点击事物
开始编程

1.创建项目，设计界面



在窗体中添加两个textbox控件和若干的button按钮，并对细节进行设计。
 public Form1()
        {
            InitializeComponent();
            CenterToScreen();  // 窗体居中
            this.FormBorderStyle = FormBorderStyle.FixedToolWindow;
            textBox1.ReadOnly = true; //使textbox1设置为只读
            textBox2.TabIndex = 0; //使光标默认在textbox2中
        }
3.对数字的输出输入进行编程
 bool iscalc = false;    //定义一个变量 用来记录上次是不是运算符
首先定义一个变量，用来记录上次按下的是不是运算符
 // 1
        private void button1_Click(object sender, EventArgs e)
        {
            if (iscalc == true)
            {
                iscalc = false;    //因为已经按下了运算符 所以再按数字的话将会清除，所以需要关闭
                textBox1.Text = "";
            }
            textBox1.Text += 1;
            textBox2.Text += 1;
        }
这是数字1的设计代码，textbox1.text  +=1；  textbox2.text  +=1；保证了数字在两个textbox上的输出。添加一个if判断，使第二次输入的数字得以保存。2.3.4.5.6.7.8.9.0的代码与1相同。

4. 对运算符进行编程
string type;  //使用这个变量用来记录按下的运算符，记录第一次输入的数字
        double num1;  // 定义这个变量是为了记录第一次输入额数据
用 string type来记录按下的运算符。

double num1 来记录第一次输入的数据。
 // +
        private void button15_Click(object sender, EventArgs e)
        {
            type = "+";
            iscalc = true;  //表示已经按下了运算符
            num1 = double.Parse(textBox1.Text); // 需要转化数据类型
            textBox2.Text += type;
        }

/ - +% 的代码相同

5.实现计算“+”，“-”，“*”，“/”, "%"的判断，在“=”按钮中编写一下代码

  private void button14_Click(object sender, EventArgs e)
        {
            iscalc = true;
            double num2 = double.Parse(textBox1.Text);
           if(type=="+")
            {
                textBox1.Text = (num1 + num2).ToString();
            }
            if (type == "-")
            {
                textBox1.Text = (num1 - num2).ToString();
            }
            if (type == "*")
            {
                textBox1.Text = (num1 * num2).ToString();
            }
            if (type == "÷")
            {
                textBox1.Text = (num1 / num2).ToString();
                if (type == "%")
                {
                    textBox1.Text = (num1 % num2).ToString();
                }
                textBox2.Text += "=" + textBox1.Text;  //  使textbox2中的算术式表达完整
            }
        }
6.最后一步对清除按钮进行编写
  //cn
        private void button19_Click(object sender, EventArgs e)
        {
            textBox1.Text = "";
            textBox2.Text = "";
        }
这样一个简单的计算器小程序就编写完成了。

Unix 系统中的 bc 命令是执行一个基于字符的计算器程序。


目录

 

bc 命令

处理大整数

可编程的 bc

什么是 dc

内部如何操作

bc 与 dc 之间的关系

bc 命令

bc 命令是任意精度计算器语言，通常在linux下当计算器用。

它类似基本的计算器, 使用这个计算器可以做基本的数学运算。

常用的运算：

+ 加法
	
- 减法
	
* 乘法
	
/ 除法
	
^ 指数
	
% 余数
举例：

2+3*4+5*10
64

bc 会显示计算结果，而且知道先算乘法在做加法。退出 bc，Ctrl+D

处理大整数

bc 的一个重要特点是，可以处理很大的整数，如：

999999999999999999999999*888888888888888888888888
888888888888888888888887111111111111111111111112

还可以通过幂运算来运算：

3333^44
10110061584495640995005898489182285794822405288498070703365111794769\
43890411064925291154381468890721948142209004688381870355409155411563\
21805747562427309521

可编程的 bc

bc 是可以编程的，可以定义变量，有逻辑判断和循环结构，语法与 c 语言类似，比如：

x = 3
if(x == 3){
 y = x*3;
}

y
9

从严格意义来说，bc 不做任何计算，主要依赖于 dc

什么是 dc

dc是一个支持非匹配精度算法的逆波兰台式计算器。

它还允许您定义和调用宏。通常dc从标准输入读取；

如果给它任何命令参数，它们就是文件名，dc在从标准输入读取之前读取并执行文件的内容。所有正常输出为标准输出；所有误差输出为标准误差。反向波兰计算器将数字存储在堆栈上。输入一个数字将其推到堆栈上。算术运算从堆栈中弹出参数并推送结果。如计算 2+3 的值，对应的逆波兰表达式为：23+，就是说操作符在后面，也成后缀表达式。

比如：

2
3
+
p
5

必须是一个数字占用一行，比如输入 2 换行，输入 3换行，输入+换行，p 是为了打印结果。输出的意思。

内部如何操作

先将 2 入栈，在将 3 入栈，然后将栈顶的两个数出站，计算他们的和，并将结果入栈，p 是为了将栈顶元素打印出来。dc 本身是一个基于栈的计算器。

bc 与 dc 之间的关系

bc 是 dc 的预处理器，他将用户输入的表达式转换成逆波兰表达式，然后通过一个成为管道的通信程序交给 dc:



对普通用户来说，bc 就是计算器。