概念解析
解释模式，是一种难度较高的设计模式：定义一个语言/文法的一种表示，并定义一个解释器，该解释器使用该文法来解释语言中的句子。 解释模式通常用于设计一个简单的语法分析工具，最显著的优点是：拓展性好，修改相应语法规则，需要修改对应模块语法即可。 解释模式类图如下：
实例分析
场景分析：设计一个简单的加减法计算器：如输入a/b/c的值，计算公式为a+b+c的数值：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
from abc import ABCMeta, abstractmethod
class Expression(metaclass=ABCMeta):
"""抽象表达式"""
@abstractmethod
def interpreter(self, var):
pass
class VarExpression(Expression):
"""变量解析器"""
def __init__(self, key):
self.__key = key
def interpreter(self, var):
return var.get(self.__key)
class SymbolExpression(Expression):
"""运算符解析器，运算符的抽象类"""
def __init__(self, left, right):
self._left = left
self._right = right
class AddExpression(SymbolExpression):
"""加法解析器"""
def __init__(self, left, right):
super().__init__(left, right)
def interpreter(self, var):
return self._left.interpreter(var) + self._right.interpreter(var)
class SubExpression(SymbolExpression):
"""减法解析器"""
def __init__(self, left, right):
super().__init__(left, right)
def interpreter(self, var):
return self._left.interpreter(var) - self._right.interpreter(var)
class Stack():
"""封装堆栈类：数据结构"""
def __init__(self):
self.items = []
def is_empty(self):
return len(self.items) == 0
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
if not self.is_empty():
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
class Calculator():
"""计算器类：实施类"""
def __init__(self, text):
self.__expression = self.parse_text(text)
def parse_text(self, exp_text):
# 定义栈，处理运算的先后顺序
stack = Stack()
left = right = None
idx = 0
while idx < len(exp_text):
if exp_text[idx] == '+':
left = stack.pop()
idx += 1
right = VarExpression(exp_text[idx])
stack.push(AddExpression(left, right))
elif exp_text[idx] == '-':
left = stack.pop()
idx += 1
right = VarExpression(exp_text[idx])
stack.push(SubExpression(left, right))
else:
stack.push(VarExpression(exp_text[idx]))
idx += 1
return stack.pop()
# 测试代码
def get_map_value(exp_str):
preidx = 0
expression_map = {}
new_exp = []
for i in range(0, len(exp_str)):
if (exp_str[i] == '+' or exp_str[i] == '-'):
key = exp_str[preidx:i]
key = key.strip()
new_exp.append(key)
new_exp.append(exp_str[i])
var = input("请输入参数" + key + "的值：")
var = var.strip()
expression_map[key] = float(var)
preidx += 1
# 处理最后一个参数
key = exp_str[preidx:len(exp_str)]
key = key.strip()
new_exp.append(key)
var = input("请输入参数" + key + "的值：")
var = var.strip()
expression_map[key] = float(var)
return new_exp, expression_map
def test_calculator():
# 获取表达式
exp_str = input("请输入表达式：")
# 获取个参数的键值对
new_exp, expression_map = get_map_value(exp_str)
calulator = Calculator(new_exp)
result = calculator.run(expression_map)
print("运算结果为：" + exp_str + " = " + str(result))