不管看多少游泳的书,跟多少游泳教练交谈,第一次游泳的时候总会沉下去。所以一定要多练习。
前两章我们聊了怎么实现两个整数的加和减,比如 “7 + 3” 和 “12 - 9”。 今天我们聊聊怎么实现任意多位数的加减,比如 “7 - 3 + 2 - 1”.
基本上,下面的图就是这种表达式的语法图:
什么是语法图呢?语法图(syntax diagram) 是用图形表示的一种编程语言的语法规则。基本上,一个语法图展现的是那些句子是合法的,那些是不合法的。
语法图很容易读,只需要沿着箭头指的路径读就可以了。有些路径表示的是决策,有些路径表示的是循环往复。
你可以这么读上面这个图:第一个短语后面随机跟着一个加或者减,然后跟着第二个短语。另一个短语可能后面又重复跟着加减和第三个短语。依次类推。你可能会追问”短语“是什么意思,好吧,本文中指的是一个整数数字。
语法图有什么作用呢?除了帮你图形化地去理解编程语言的规范(语法),还可以帮你去写你自己的解析器。
关于后者,这里要详细说说。
从语法图上看,下面的表达式都应该是合法的:
- 3
- 3 + 4
- 7 - 3 + 2 - 1
“3 + ” 就不是一个合法的算术表达式,因为根据语法图,加号后面必须跟着一个短语,也就是整数,否则就是一个语法错误。下面的代码片段展示了语法图的解析过程。图中的长方形变成 了一个方法,叫term,它用来解析一个整数。expr方法用来遍历语法图。
def term(self):
self.eat(INTEGER)
def expr(self):
# set current token to the first token taken from the input
self.current_token = self.get_next_token()
self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
self.term()
elif token.type == MINUS:
self.eat(MINUS)
self.term()
def term(self):
"""Return an INTEGER token value"""
token = self.current_token
self.eat(INTEGER)
return token.value
def expr(self):
"""Parser / Interpreter """
# set current token to the first token taken from the input
self.current_token = self.get_next_token()
result = self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
result = result + self.term()
elif token.type == MINUS:
self.eat(MINUS)
result = result - self.term()
return result
从代码中看的很清楚,expr首先调用了term方法,接着就是一个while循环。循环内部解析器根据不同的token来决定是做加法,还是做减法。 不过解释器本身并没有interpret什么,当他识别出来一个表达式的时候,他就忽略掉;如果没有识别出来,他就报告异常错误。
所以下面我们在expr方法中,加一些interpreter的代码。
interpreter需要评估term返回给它的表达式,代码如下。这份代码支持了任意多数字的加减操作。
# Token types
#
# EOF (end-of-file) token is used to indicate that
# there is no more input left for lexical analysis
INTEGER, PLUS, MINUS, EOF = 'INTEGER', 'PLUS', 'MINUS', 'EOF'
class Token(object):
def __init__(self, type, value):
# token type: INTEGER, PLUS, MINUS, or EOF
self.type = type
# token value: non-negative integer value, '+', '-', or None
self.value = value
def __str__(self):
"""String representation of the class instance.
Examples:
Token(INTEGER, 3)
Token(PLUS, '+')
"""
return 'Token({type}, {value})'.format(
type=self.type,
value=repr(self.value)
)
def __repr__(self):
return self.__str__()
class Interpreter(object):
def __init__(self, text):
# client string input, e.g. "3 + 5", "12 - 5 + 3", etc
self.text = text
# self.pos is an index into self.text
self.pos = 0
# current token instance
self.current_token = None
self.current_char = self.text[self.pos]
##########################################################
# Lexer code #
##########################################################
def error(self):
raise Exception('Invalid syntax')
def advance(self):
"""Advance the `pos` pointer and set the `current_char` variable."""
self.pos += 1
if self.pos > len(self.text) - 1:
self.current_char = None # Indicates end of input
else:
self.current_char = self.text[self.pos]
def skip_whitespace(self):
while self.current_char is not None and self.current_char.isspace():
self.advance()
def integer(self):
"""Return a (multidigit) integer consumed from the input."""
result = ''
while self.current_char is not None and self.current_char.isdigit():
result += self.current_char
self.advance()
return int(result)
def get_next_token(self):
"""Lexical analyzer (also known as scanner or tokenizer)
This method is responsible for breaking a sentence
apart into tokens. One token at a time.
"""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char.isdigit():
return Token(INTEGER, self.integer())
if self.current_char == '+':
self.advance()
return Token(PLUS, '+')
if self.current_char == '-':
self.advance()
return Token(MINUS, '-')
self.error()
return Token(EOF, None)
##########################################################
# Parser / Interpreter code #
##########################################################
def eat(self, token_type):
# compare the current token type with the passed token
# type and if they match then "eat" the current token
# and assign the next token to the self.current_token,
# otherwise raise an exception.
if self.current_token.type == token_type:
self.current_token = self.get_next_token()
else:
self.error()
def term(self):
"""Return an INTEGER token value."""
token = self.current_token
self.eat(INTEGER)
return token.value
def expr(self):
"""Arithmetic expression parser / interpreter."""
# set current token to the first token taken from the input
self.current_token = self.get_next_token()
result = self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
result = result + self.term()
elif token.type == MINUS:
self.eat(MINUS)
result = result - self.term()
return result
def main():
while True:
try:
# To run under Python3 replace 'raw_input' call
# with 'input'
text = raw_input('calc> ')
except EOFError:
break
if not text:
continue
interpreter = Interpreter(text)
result = interpreter.expr()
print(result)
if __name__ == '__main__':
main()
运行一下试试:
$ python calc3.py
calc> 3
3
calc> 7 - 4
3
calc> 10 + 5
15
calc> 7 - 3 + 2 - 1
5
calc> 10 + 1 + 2 - 3 + 4 + 6 - 15
5
calc> 3 +
Traceback (most recent call last):
File "calc3.py", line 147, in <module>
main()
File "calc3.py", line 142, in main
result = interpreter.expr()
File "calc3.py", line 123, in expr
result = result + self.term()
File "calc3.py", line 110, in term
self.eat(INTEGER)
File "calc3.py", line 105, in eat
self.error()
File "calc3.py", line 45, in error
raise Exception('Invalid syntax')
Exception: Invalid syntax
在多思考一下,动手画一下写一写。
- 画一个语法图,只包含乘除法,比如“7 * 4 / 2 * 3”。说真的呢,用笔画一画。
- 改一下interpreter代码,让它只包含乘除。
- 从头写一遍interpreter。脑子中想着这几个概念:词法分析器把输入字符串转换为token序列,解析器拿到token序列后识别内部的结构,interpreter在解析器成功解析后得到运算结果。