python 设计模式之解释器(Interpreter)模式

from abc import ABCMeta, abstractmethod

class AbstractExpression():
    """
    抽象表达式类，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享
    """
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def interpret(self, context):
        pass
    
class TerminalExpression(AbstractExpression):
    """
    终结符表达式，实现与文法中的终结符相关联的解释操作。实现抽象表达式中所要求的接口，主要是一个interpret()方法。
    文法中的每一个终结符都有一个具体终结符表达式与之相对应。
    """
    def interpret(self, context):
        print("终结符表达式")
        
        
class NontermialExpression(AbstractExpression):
    """
    非终结符表达式，为文法中的非终结符实现解释操作。对文法中每一条规则R1，R2，...Rn都需要一个具体的非终结符表达式类。
    通过实现抽闲表达式的interpret()方法实现解释操作。解释操作以递归的方式调用上 main所提到的代表R1，R2，...Rn中各
    个符号的实例变量。
    """
    def interpret(self, context):
        print("非终结符表达式")
        
        
class Context():
    """
    上下文类，包含解释器之外的一些全局信息
    """
    def __init__(self):
        self.input = None
        self.output = None
        
        
def main():
    """
    客户端代码，构建表示该文法定义的语言中一个特定的句子的抽象语法树。
    """
    context = Context()
    exp_list = []
    exp_list.append(TerminalExpression())
    exp_list.append(NontermialExpression())
    exp_list.append(TerminalExpression())
    exp_list.append(NontermialExpression())
    
    for exp in exp_list:
        exp.interpret(context)
        
main()

class Variables(object):  # Context
    def __init__(self):
        self._v = {}
    def put(self, variable, value: int):
        self._v[variable] = value
    def get(self, variable) -> int:
        return self._v.get(variable)

class ArithmeticExpression(object):  # AbstractExpression
    def interpret(self, variables) -> float:
        pass

class Variable(ArithmeticExpression):  # TerminalExpression
    def __init__(self, value: str):
        self.variable = value
    def interpret(self, variables):
        return variables.get(self.variable)

class Plus(ArithmeticExpression):  # NonTerminalExpression
    def __init__(self, left: ArithmeticExpression, right: ArithmeticExpression):
        self._left = left
        self._right = right
    def interpret(self, variables: Variables):
        return self._left.interpret(variables) + self._right.interpret(variables)

class Substract(ArithmeticExpression):  # NonTerminalExpression
    def __init__(self, left: ArithmeticExpression, right: ArithmeticExpression):
        self._left = left
        self._right = right
    def interpret(self, variables: Variables):
        return self._left.interpret(variables) - self._right.interpret(variables)

class Multiply(ArithmeticExpression):  # NonTerminalExpression
    def __init__(self, left: ArithmeticExpression, right: ArithmeticExpression):
        self._left = left
        self._right = right
    def interpret(self, variables: Variables):
        return self._left.interpret(variables) * self._right.interpret(variables)

class Division(ArithmeticExpression):  # NonTerminalExpression
    def __init__(self, left: ArithmeticExpression, right: ArithmeticExpression):
        self._left = left
        self._right = right
    def interpret(self, variables: Variables):
        return self._left.interpret(variables) / self._right.interpret(variables)



class Calculator(object):
    def __init__(self, expression: str, context: Variables):
        self.expression = expression
        self.context = context
        self.value = None
    def get_value(self):
        self.calculate()
        return self.value
    def calculate(self):
        OP = ['+', '-', '*', '/', '(', ')', '=']
        priority = [  # 各运算符相遇时，优先级比较 1: 大于，2: 小于，3: 多弹一个符号
            [1, 1, 2, 2, 2, 1, 1],
            [1, 1, 2, 2, 2, 1, 1],
            [1, 1, 1, 1, 2, 1, 1],
            [1, 1, 1, 1, 2, 1, 1],
            [2, 2, 2, 2, 2, 3, 0],
            [1, 1, 1, 1, 0, 1, 1],
            [2, 2, 2, 2, 2, 0, 3]
        ]
        opan = []  # 操作数
        opat = ['=']  # 操作符，初始带一个=为的是作为结束符使用
        for char in self.expression:
            while True:
                if char not in OP:  # 变量
                    opan.append(Variable(char))
                    break
                else:  # 操作符
                    level = priority[OP.index(opat[-1::1][0])][OP.index(char)]
                    if level == 1:
                        op = opat.pop()
                        b = opan.pop()
                        a = opan.pop()
                        if op == '+':
                            opan.append(Plus(a, b))
                        elif op == '-':
                            opan.append(Substract(a, b))
                        elif op == '*':
                            opan.append(Multiply(a, b))
                        elif op == '/':
                            opan.append(Division(a, b))
                    elif level == 2:
                        opat.append(char)
                        break
                    elif level == 3:
                        opat.pop()
                        break
                    else:
                        break
        self.value = opan.pop().interpret(self.context)


if __name__ == '__main__':
    variables = Variables()
    variables.put('a', 1)
    variables.put('b', 2)
    variables.put('c', 3)
    variables.put('d', 4)
    aa = Variable('a')
    bb = Variable('b')
    cc = Variable('c')
    dd = Variable('d')
    # (1-2)+(3*4)
    print(Plus(Substract(aa, bb), Multiply(cc, dd)).interpret(variables))
    print(Calculator('a-b+c*d=', variables).get_value())