Python实现支持连续运算的计算器逻辑

一、连续运算的核心机制与状态流转

在常规的一次性运算中，程序通常只需要接收形如 A + B 的完整表达式，计算出结果后便销毁上下文。但在交互式计算器中，用户往往期望前一步的计算结果能够直接充当下一步运算的左操作数。例如输入 15 + 5 后紧接着按下 *，计算器必须先将 15 + 5 结算为 20，再将 20 作为乘法的被乘数等待下一个输入。

为了让计算过程连贯稳定，我们需要建立一个清晰的状态模型。整个计算引擎由以下三个核心状态变量构成：

• 累加寄存器（Accumulator / Current Result）：保存当前已确认计算阶段的最终数值。在输入第一个数时，该值作为初始基准；后续每次触发新运算，计算结果都会刷新写回此处。
• 挂起操作符（Pending Operator）：记录上一次输入但尚未执行的运算符。当新的操作符到达时，系统依据该操作符执行运算，并在运算完毕后用新操作符将其替换。
• 操作数缓冲区（Input Buffer / Next Number）：暂存当前用户正在输入的第二操作数。当检测到等号或下一个连续运算符时，该缓冲区数值与累加寄存器进行求值。

二、逐步实现：基于状态机的即时连续求值

我们首先从最直观的“即时求值（Immediate Execution）”机制入手。标准手持计算器通常采用这种模式：当用户依次按下数字和符号时，每当按下第二个操作符，计算器立即计算出前面已输入部分的结果并显示在屏幕上。

下面是一个纯粹基于函数和全局状态概念的交互式示例。通过一个清晰的 step() 函数，读者可以直观观察到数据在每一步输入时的具体变化：

import operator

# 定义算术调度字典，避免重复分支判断
OPERATIONS = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv
}

class SimpleChainedCalc:
    def __init__(self):
        self.accumulator = None      # 累加结果
        self.pending_operator = None # 挂起的运算符

    def input_number(self, num: float):
        # 如果当前没有累加值，说明是第一个操作数
        if self.accumulator is None:
            self.accumulator = num
            return self.accumulator

        # 如果已有累加值且有待决运算符，执行运算
        if self.pending_operator:
            op_func = OPERATIONS[self.pending_operator]
            if self.pending_operator == '/' and num == 0:
                raise ZeroDivisionError("除数不能为0")
            self.accumulator = op_func(self.accumulator, num)
            self.pending_operator = None
        else:
            # 没有待决操作符，说明是全新输入
            self.accumulator = num
        return self.accumulator

    def input_operator(self, op: str):
        if op not in OPERATIONS:
            raise ValueError(f"不支持的操作符: {op}")
        self.pending_operator = op

    def equals(self):
        # 获取最终累加结果并复位状态
        result = self.accumulator
        self.pending_operator = None
        return result

以表达式 15 + 5 * 2 = 为例，如果在即时连续运算模式下，其求值步骤并非数学上的“先乘除后加减”，而是严格遵循输入的先后顺序流转。

三、处理运算符优先级：即时模式与双栈模型对比

在设计计算器时，许多初学者会疑惑：为什么输入 15 + 5 * 2，普通计算器算出的是 40，而数学公式计算出的却是 25？

这涉及到两种截然不同的架构取向：

• 即时求值模式（Immediate Evaluation）：严格按照用户击键的时序进行链式计算。每输入一个操作符，就将前面的内容压扁为一个数值。它的优点是内存开销恒定为 $O(1)$，对单行显示屏或简单交互界面非常友好，符合多数人使用实体计算器的直觉。
• 双栈优先级求值模式（Dual Stack / Shunting-yard）：分别维护“操作数栈”与“操作符栈”。当新操作符的优先级高于栈顶操作符（如乘除遇到加减）时，操作符先入栈暂存；当新操作符优先级低于或等于栈顶操作符时，才触发栈顶规约。这能严格实现数学标准运算，适合科学计算器。

四、进阶封装：工业级计算器引擎实现

为了让计算器逻辑具有工业级实用性，代码需要具备防御式编程能力：包括优雅处理多次连续输入操作符（符号覆盖）、避免原生 float 导致的十进制精度丢失问题（如 0.1 + 0.2 = 0.30000000000000004），以及拦截除以零导致的程序崩溃。

以下为经过系统封装的 ContinuousCalculator 完整实现：

from decimal import Decimal, InvalidOperation
from typing import Optional, Union

class ContinuousCalculator:
    """支持连续链式运算的计算器引擎"""

    def __init__(self):
        self._accumulator: Optional[Decimal] = None
        self._pending_operator: Optional[str] = None
        self._waiting_for_operand: bool = True
        self._last_operand: Optional[Decimal] = None
        self._last_operator: Optional[str] = None

    def reset(self):
        """完全重置计算器上下文"""
        self._accumulator = None
        self._pending_operator = None
        self._waiting_for_operand = True
        self._last_operand = None
        self._last_operator = None

    def _execute_op(self, a: Decimal, op: str, b: Decimal) -> Decimal:
        """纯函数运算映射与异常守卫"""
        if op == '+':
            return a + b
        elif op == '-':
            return a - b
        elif op == '*':
            return a * b
        elif op == '/':
            if b == Decimal('0'):
                raise ZeroDivisionError("数学错误：除数不能为 0")
            return a / b
        else:
            raise ValueError(f"未知的操作符: {op}")

    def input_number(self, value: Union[int, float, str, Decimal]) -> Decimal:
        """输入数值，并转换为精确的 Decimal"""
        try:
            current_num = Decimal(str(value))
        except (InvalidOperation, TypeError):
            raise ValueError(f"无效的数字输入: {value}")

        if self._accumulator is None:
            # 首次输入数字
            self._accumulator = current_num
            self._waiting_for_operand = False
            return self._accumulator

        if self._waiting_for_operand:
            # 处于等待操作数状态，当前输入即为第二操作数
            if self._pending_operator is not None:
                self._accumulator = self._execute_op(
                    self._accumulator, self._pending_operator, current_num
                )
                self._last_operand = current_num
                self._last_operator = self._pending_operator
                self._pending_operator = None
            else:
                self._accumulator = current_num
            self._waiting_for_operand = False
        else:
            # 没有待决操作符且不在等待中，直接覆盖累加值（类似重置后新输入）
            self._accumulator = current_num

        return self._accumulator

    def input_operator(self, op: str):
        """输入运算符，自动处理连续输入符号的覆盖逻辑"""
        if op not in {'+', '-', '*', '/'}:
            raise ValueError(f"不支持的运算符: {op}")

        # 如果用户刚按过操作符又按了另一个操作符（如先按 + 后改按 *），直接替换操作符
        if self._waiting_for_operand and self._accumulator is not None:
            self._pending_operator = op
            return

        self._pending_operator = op
        self._waiting_for_operand = True

    def equals(self) -> Decimal:
        """按下等号：支持连续重复按等号执行上一次运算"""
        if self._accumulator is None:
            return Decimal('0')

        # 如果存在记录的上次操作数与操作符，支持连续按 '=' 累加效果
        if self._pending_operator is None and self._last_operator and self._last_operand is not None:
            self._accumulator = self._execute_op(
                self._accumulator, self._last_operator, self._last_operand
            )
            return self._accumulator

        self._pending_operator = None
        self._waiting_for_operand = True
        return self._accumulator

    @property
    def display_value(self) -> str:
        """获取用于格式化显示的当前结果"""
        if self._accumulator is None:
            return "0"
        # 去除末尾冗余零并格式化
        normalized = self._accumulator.normalize()
        return f"{normalized:f}" if normalized.as_tuple().exponent < 0 else str(normalized)

通过这套封装，我们可以轻松通过链式调用模拟用户的各种真实击键行为：

calc = ContinuousCalculator()

# 模拟 10 + 20 - 5 * 2
calc.input_number(10)
calc.input_operator('+')
calc.input_number(20)  # 此时内部已结算为 30
calc.input_operator('-')
calc.input_number(5)   # 此时内部已结算为 25
calc.input_operator('*')
calc.input_number(2)   # 此时内部已结算为 50
calc.equals()

print("最终计算结果:", calc.display_value) # 输出 50

五、常见问题排查与注意事项