[Python实战]使用栈实现简易计算器-CSDN博客

本文链接：https://blog.csdn.net/weixin_43773093/article/details/99520950

我们这次实现的命令行计算器，支持加减乘除、括号、浮点数、负数，以及查看历史和退出功能。

主要的思路：read - parse - print - loop。

read 阶段是指读取用户在提示符(cal> )之后输入的字符串。

parse 阶段包括：将用户输入的字符串分割成单个对象比如：符号 +，或者数字 1.2 。其次将中缀表达式转化后缀表达式，接下来计算后缀表达式的数值。

print 阶段指的是将 parse 阶段的数值打印在终端上。

loop 阶段是指重复上述操作，除非用户输入 exit 符号或者 Ctrl + C 终止程序运行。

实现效果图：

栈

为了实现后面的中缀、后缀表达式，我们需要借助栈这种数据结构。

栈是一种先进后出的数据结构，函数调用时就会使用栈来保存当前程序的地址及其他信息，前面的深度优先搜索就是基于栈实现的。

之前写了一篇文章介绍了栈的用法，下面简单说明栈的使用：

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