以上是解释器模式的类图，解释器模式是当年GoF（俗称四人帮）面向对象的二十三种模式中的一种，这种模式的主要应用场景是按照既定的规则解析字符串，可以用来解析日志，当然非常牛逼的人可能会写个自己发明一种语言，用这种模式写个解释器。
这种模式的核心分为两大部分，一是上下文（Context），另一个就是表达式（Expression），而两者之中的重点是表达式，表达式分为两种：终结表达式（TerminalExpression）和非终结表达式（NonterminalExpression）。顾名思义，终结表达式可以作为表达式的终点，而非终结表达式不能。等一下我们的例子中，我会很清楚地标记出这几个关键点。
- 案例需求：
1、通过交互程序设置变量，为了简单，变量名为一个字母，值为整数即可。
2、通过交互程序输入算式，算式由之前设置的变量和加减乘除还有圆括号组成。
3、按照正常的四则运算的优先级进行计算。
4、输出计算结果。
5、可以支持加入自定义二元运算符的扩展。
有了需求，我们就可以动工了。
需求是按照业务流程从前到后一步一步描述的，但是我们切不可从前到后一点点的写程序，我们要对需求进行分析，再慢慢动手写代码。我们首先应该分析出的是这个小程序的核心，也就是我们编码的重点，应该放在第三步运算优先级和第五步支持扩展上。为达到这两个重点，就要用到我们题目中的两个技巧，解释器模式（解决第五步问题）+栈解析算式（解决第三步问题）。剩下前两步是交互，我开发时可以先用写死的数据，再改由用户输入即可，第四步是顺理成章的事情，这些都不需要太多关注。
我们的两个重点工作中解释器模式是框架，栈解析是灵魂，我们可以选择先搭架子，再注入灵魂，也可以先塑造灵魂，再纺织框架，在此我选择先搭架。
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)
根据类图，这样解释器模式的框架就搭好了，到底好不好用呢？我们需要紧接着用一段代码测试一下。
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))
经过测试我们得到了正确的结果，说明我们的解释器框架已经基本成形了，我们就可以开始下一步解析算式了。
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)
这个算法并非我原创，是根据经典的C++代码改写的，这个算法巧妙地运用了栈后进先出的特性解决了优先级问题，通过二维列表定义了各符号的优先级，避免了大量的if...else...。我们再用刚才的算式验证一下效果如何。
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())
可以看到结果是正确的，但表达式非要带个等于号结尾，略显尴尬，优化方法很简单，只需要在__init__方法中判断一下是否以等号结尾，不以等号结尾的加上等号即可。
...
def __init__(self, expression: str, context: Variables):
self.expression = expression if expression[-1::1][0] == '=' else expression + '='
self.context = context
self.value = None
...
这时我们发现，我们只能传入仅含有变量和运算符的算式，如果我们想输入变量及运算符还要有数字的算式，怎么处理呢？我们可以对Variable进行改写，使其执行解释器方法时判断自己的值是字母，就到Context中取相应的值，如果自己的值就是数字，直接就返回数字。
import re
class Variable(ArithmeticExpression): # TerminalExpression
def __init__(self, value: str):
self.value = None
if re.match('\d+', value):
self.value = int(value)
else:
self.variable = value
def interpret(self, variables):
if self.value:
return self.value
return variables.get(self.variable)
至此，两大核心就全部编写完成了，至于交互与扩展，这里就不再赘述了。
