Python中怎么使用栈实现简易计算器-创新互联

这篇文章主要介绍“Python中怎么使用栈实现简易计算器”，在日常操作中，相信很多人在Python中怎么使用栈实现简易计算器问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Python中怎么使用栈实现简易计算器”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

主要的思路：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

到此，关于“Python中怎么使用栈实现简易计算器”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联-成都网站建设公司网站，小编会继续努力为大家带来更多实用的文章！