我们这次实现的命令行计算器，支持加减乘除、括号、浮点数、负数，以及查看历史和退出功能。
主要的思路：read - parse - print - loop。
read 阶段是指读取用户在提示符(cal> )之后输入的字符串。
parse 阶段包括：将用户输入的字符串分割成单个对象比如：符号 +，或者数字 1.2 。其次将中缀表达式转化后缀表达式，接下来计算后缀表达式的数值。
print 阶段指的是将 parse 阶段的数值打印在终端上。
loop 阶段是指重复上述操作，除非用户输入 exit 符号或者 Ctrl + C 终止程序运行。
实现效果图：
![[Python实战]使用栈实现简易计算器_第1张图片](https://img.it610.com/image/info8/7f7d69d039c442818d1256bf9260ef2d.gif)
栈
为了实现后面的中缀、后缀表达式，我们需要借助栈这种数据结构。
栈是一种先进后出的数据结构，函数调用时就会使用栈来保存当前程序的地址及其他信息，前面的深度优先搜索就是基于栈实现的。
之前写了一篇文章介绍了栈的用法，下面简单说明栈的使用：
push 函数在栈的顶部添加元素，pop 函数删除栈顶的元素，top 函数查看栈顶元素。
class Stack:
def push(self, value: T) -> None: pass
def pop(self) -> T: pass
def top(self) -> T: pass
分词
分词是 parse 阶段的重要部分。
-
我们定义符号 + - * / ( )。
-
将这些字符串中的这些符号替换为：空格 + 符号 + 空格
+ => 空格+空格
-
将字符串按空格分割，得到最终的分词
经过上述操作，就可以实现对正数以及操作符的分词功能。
# Python高效编程
def tokenize(expression: str) -> Generator[str, None, None]:
for symbol in symbols:
# 替换字符串
expression = expression.replace(symbol, f" {symbol} ")
# 分割字符串
seq: List[str] = expression.split()
为了实现对负数的分词，我们需要迭代分词序列，将‘-’ 与后面的数字转换成一个整体。我们有两种情况将 - 视作负号，第一种情况，负号位于字符串的开头；第二种情况，负号前一个符号为左括号。
# Python高效编程
for i, item in enumerate(expression.split()):
if item == "-":
# 两种情况下，当前符号设置为 ""
# 下一个符号设置为负数
if i - 1 < 0 or seq[i - 1] == "(":
seq[i] = ""
seq[i + 1] = f"-{seq[i + 1]}"
# 若字符串不为空，打印字符串
if seq[i]:
yield seq[i]
中缀表达式
中缀表达式就是我们写的各种表达式，如 3 + 2 * 4。我们希望将其转化为后缀表达式，示例如下：
中缀表达式 ==> 1 + 5 * 4 + (3 * 2 + 4) * 6
后缀表达式 ==> 1 5 4 * + 3 2 * 4 + 6 * +
我们需要准备一个栈 stack ，用于临时存放操作符；准备一个序列 seq，用来存放输出结果，也就是后缀表达式。
转化规则：
迭代分词序列，遇到数字，就将数字输出到序列 seq 中。
定义各个符号优先级，其中 乘除 > 加减 > 右括号。比较当前符号与栈顶元素的优先级，如果当前元素的优先级小于等于栈顶元素的优先级，就弹出栈顶元素，输出到 seq 序列中，然后将当前元素压入栈中。如果当前元素的优先级大于栈顶元素的优先级，或者当前元素为右括号，我们直接将当前元素压入栈中。
如果遇到左括号，我们就弹出栈中元素，并输出到 seq 序列中。其中，左右括号不输出到序列中。
最后，将栈中剩余的符号输出到 seq 序列中。
# Python高效编程
# 迭代 1 + 5 * 4 + (3 * 2 + 4) * 6
# 读入 1 并输出到 seq 中，将 + 压入栈中
# 读入 5 并输出到 seq 中
stack ==> +
seq ==> 1 5
# 读入 *, * 优先级 > + 优先级
# 将 * 压入栈中, 读入 4 并输出
stack ==> + *
seq ==> 1 5 4
# 读入 +， + 优先级 < * 优先级
# 将 * 输出到 seq 序列中
# + 优先级 <= + 优先级，+ 输出
# 将 + 压入栈中
stack ==> +
seq ==> 1 5 4 * +
# 读入 (, 压入栈中，读入 3，压入栈中
stack ==> + (
seq ==> 1 5 4 * + 3
# 读入 *, 压入栈中，读入 2，压入栈中
stack ==> + ( *
seq ==> 1 5 4 * + 3 2
# 读入 +，* 输出，+ 压入栈中， 4 输出
stack ==> + ( +
seq ==> 1 5 4 * + 3 2 * 4
# 读入 )，+ 输出，弹出 (
stack ==> +
seq ==> 1 5 4 * + 3 2 * 4 +
# 读入 *, 压入栈中, 6 输出
stack ==> + *
seq ==> 1 5 4 * + 3 2 * 4 + 6
# 将栈中剩余符号输出
stack ==>
seq ==> 1 5 4 * + 3 2 * 4 + 6 * +
代码如下：
# Python高效编程
def parse_infix(expression: str) -> List[str]:
stack: Stack[str] = Stack()
result: List[str] = []
for expr in tokenize(expression):
if not is_float(expr) and expr not in symbols:
raise SymbolError()
if is_float(expr):
result.append(expr)
elif expr == ")":
while stack.top != "(":
result.append(stack.pop())
stack.pop()
elif expr == "(":
stack.push(expr)
elif stack.top and compare_priority(expr, stack.top):
result.append(stack.pop())
while stack.top and compare_priority(expr, stack.top):
result.append(stack.pop())
stack.push(expr)
else:
stack.push(expr)
while stack:
result.append(stack.pop())
return result
后缀表达式
后缀表达式的规则：遇到数值就压入栈中；遇到符号，就从栈中弹出两个元素，计算两个元素运算结果，将得到的结果压入栈中。
# Python高效编程
def parse_sufix(expression: List[str]) -> float:
stack: Stack[str] = Stack()
result: float = 0.0
for expr in expression:
if is_float(expr):
stack.push(expr)
else:
elem1: str = stack.pop()
elem2: str = stack.pop()
result = evaluate(expr, float(elem2), float(elem1))
stack.push(str(result))
if stack:
result = float(stack.pop())
return result
总结
接下来还有添加查看历史和退出功能以及整个程序的组成，关注微信公众号
python高效编程
在后台回复
2019813
获取源代码及 exe 文件。
