解释器模式示例

import abc

class Interpreter(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def interpret(self, expression):
        pass

class SimpleInterpreter(Interpreter):
    def interpret(self, expression):
        result = self.evaluate(expression)
        return result

    def evaluate(self, expression):
        raise NotImplementedError("evaluate method is not implemented")

class AdvancedInterpreter(Interpreter):
    def interpret(self, expression):
        result = self.evaluate(expression)
        return result

    def evaluate(self, expression):
        raise NotImplementedError("evaluate method is not implemented")

class Expression(object):
    def __init__(self, value):
        self.value = value

    def interpret(self):
        raise NotImplementedError("interpret method is not implemented")

class SimpleExpression(Expression):
    def __init__(self, value):
        super().__init__(value)

    def interpret(self):
        return self.value

class AdvancedExpression(Expression):
    def __init__(self, value, operator):
        super().__init__(value)
        self.operator = operator

    def interpret(self):
        operand1 = self.evaluate(self.value)
        operand2 = self.evaluate(self.operator)
        return self.calculate(operand1, operand2)

    def evaluate(self, expression):
        raise NotImplementedError("evaluate method is not implemented")

    def calculate(self, operand1, operand2):
        raise NotImplementedError("calculate method is not implemented")

# 使用解释器模式实现一个简单的计算器
def add(expression):
    operand1 = expression.evaluate(SimpleExpression("2"))
    operand2 = expression.evaluate(SimpleExpression("3"))
    return operand1 + operand2

def subtract(expression):
    operand1 = expression.evaluate(SimpleExpression("5"))
    operand2 = expression.evaluate(SimpleExpression("2"))
    return operand1 - operand2

def multiply(expression):
    operand1 = expression.evaluate(SimpleExpression("4"))
    operand2 = expression.evaluate(SimpleExpression("3"))
    return operand1 * operand2

def divide(expression):
    operand1 = expression.evaluate(SimpleExpression("6"))
    operand2 = expression.evaluate(SimpleExpression("2"))
    return operand1 / operand2

expression = SimpleExpression("4") + SimpleExpression("3")
print("4 + 3 =", expression.interpret()) # 输出 7

expression = SimpleExpression("5") - SimpleExpression("2")
print("5 - 2 =", expression.interpret()) # 输出 3

expression = SimpleExpression("4") * SimpleExpression("3")
print("4 * 3 =", expression.interpret()) # 输出 12

expression = SimpleExpression("6") / SimpleExpression("2")
print("6 / 2 =", expression.interpret()) # 输出 3

expression = add(expression)
print("4 + 3 =", expression.interpret()) # 输出 7

expression = subtract(expression)
print("4 + 3 =", expression.interpret()) # 输出 1

expression = multiply(expression)
print("4 + 3 =", expression.interpret()) # 输出 12

expression = divide(expression)
print("4 + 3 =", expression.interpret()) # 输出 2.0