Python 扩展buildParseTree方法，使其能处理字符间没有空格的数学表达式。

### 回答1：
我明白了您的问题，不用担心，Python 中的 Ply 库可以实现这个功能。您可以创建自己的 Lex 和 Yacc 文件，并使用 Ply 库的语法规则来解析表达式。以下是一个简单的示例：

首先，我们需要安装 Ply 库：

pip install ply

接下来，我们创建一个名为 calc.py 的文件，其中包含 Lex 和 Yacc 规则以及代码。在该文件中，我们需要定义以下内容：

1. Lex 规则：这些规则定义了我们要解析的输入的词汇特征，如数字、运算符、括号等。在本例中，我们定义了上述内容。

2. Yacc 规则：这些规则定义了语法、运算顺序和结构。我们定义了基本的算术运算，例如加、减、乘、除和括号。

3. 将运算符映射到相应的 Python 函数。

这是 calc.py 文件的内容：

import ply.lex as lex
import ply.yacc as yacc

# Lex 规则
tokens = (
   'NUMBER',
   'PLUS',
   'MINUS',
   'TIMES',
   'DIVIDE',
   'LPAREN',
   'RPAREN',
)

t_PLUS    = r'\+'
t_MINUS   = r'-'
t_TIMES   = r'\*'
t_DIVIDE  = r'/'
t_LPAREN  = r'\('
t_RPAREN  = r'\)'

def t_NUMBER(t):
    r'\d+'
    t.value = int(t.value)
    return t

t_ignore = ' \t'

def t_error(t):
    print("Illegal character '%s'" % t.value[0])
    t.lexer.skip(1)

# Yacc 规则

def p_expression_plus(p):
    'expression : expression PLUS term'
    p[0] = p[1] + p[3]

def p_expression_minus(p):
    'expression : expression MINUS term'
    p[0] = p[1] - p[3]

def p_expression_term(p):
    'expression : term'
    p[0] = p[1]

def p_term_times(p):
    'term : term TIMES factor'
    p[0] = p[1] * p[3]

def p_term_div(p):
    'term : term DIVIDE factor'
    p[0] = p[1] / p[3]

def p_term_factor(p):
    'term : factor'
    p[0] = p[1]

def p_factor_num(p):
    'factor : NUMBER'
    p[0] = p[1]

def p_factor_expr(p):
    'factor : LPAREN expression RPAREN'
    p[0] = p[2]

def p_error(p):
    print("Syntax error at '%s'" % p.value)

lexer = lex.lex()
parser = yacc.yacc()

# 测试
while True:
    try:
        s = input('calc > ')
    except EOFError:
        break
    if not s:
        continue
    result = parser.parse(s)
    print(result)

以上代码中，我们定义了 Lex 规则，将输入字符串分为数字、加号、减号、乘号、除号和括号等词汇。然后，我们定义了一个简单的 Yacc 语法，将这些词汇组合成表达式、项和因子。我们还将运算符映射到相应的 Python 函数，然后使用 Ply 库的 Lex 和 Yacc 解析器将表达式转换为计算结果。

您可以在控制台上运行此脚本，然后键入要计算的表达式，如“2 + 3 * 4”。该脚本将解析该表达式，计算结果并打印出来。

### 回答2：
要扩展Python的buildParseTree方法，使其能处理字符间没有空格的数学表达式，我们可以采取以下步骤：
第一步，我们需要检测输入的表达式中是否存在运算符。我们可以遍历整个表达式，当遇到非数字字符时，即判断为运算符。
第二步，当我们找到运算符后，我们需要确定该运算符的优先级。可以将这些运算符按照优先级顺序排列，并根据优先级确定它们的位置。例如，加法和减法的优先级较低，乘法和除法的优先级较高。
第三步，我们需要确定每个操作数。由于输入的表达式中没有空格，所以无法通过空格来分割操作数。我们可以遍历表达式，当我们遇到运算符时，我们可以将该字符之前的所有字符作为一个操作数。在找到运算符之后，我们需要继续遍历直到找到下一个运算符或到达表达式的末尾，然后将该字符之前的字符作为下一个操作数。
第四步，我们可以使用递归的方式来构建语法树。我们首先确定根节点，该节点是表达式的第一个操作数。然后我们依次处理所有的操作符和操作数，将它们添加到树中。树的结构可以基于Python的类和对象构建。
第五步，我们需要为树添加方法来计算表达式的值。可以通过深度优先搜索（DFS）遍历整个树，并根据树的节点类型执行相应的操作。例如，当我们遇到一个运算符节点时，我们需要将其两个子节点的值根据运算符进行运算。当我们遇到一个操作数节点时，我们可以直接返回其存储的数字值。
通过以上步骤，我们可以成功扩展Python的buildParseTree方法，使其能够处理字符间没有空格的数学表达式。

### 回答3：
为了使Python扩展的buildParseTree方法能够处理字符间没有空格的数学表达式，我们需要对其进行一些修改。首先，我们需要修改语法规则，以识别没有空格的数学表达式。
我们可以将原来的语法规则：
expression -> term { ('+'|'-') term }
term -> factor { ('*'|'/') factor }
factor -> ('+'|'-') factor | number | '(' expression ')'
简化为：
expression -> term { ('+'|'-'|'*'|'/') term }
term -> number | '(' expression ')'
接下来，我们需要修改Token类的定义，以处理没有空格的表达式。原来的Token类定义：
class Token(object):
def __init__(self, value):
self.value = value
新的Token类定义：
class Token(object):
def __init__(self, value, type):
self.value = value
self.type = type
我们需要在Token类中添加一个type属性，该属性表示该Token的类型。然后，在buildParseTree方法中，我们需要根据字符的特点进行修改。假设我们的输入是一个字符串expression，我们可以通过使用Python内置的re模块来解析表达式。我们可以使用re模块的findall方法，通过一个正则表达式来找到表达式中的所有数字、操作符和括号。然后，我们可以将找到的每一个字符包装成一个Token对象，并加入到tokens列表中。最后，我们只需要按照正确的顺序来构建parse tree，就可以得到正确的结果。
总结一下，我们可以通过修改语法规则、修改Token类的定义，并在buildParseTree方法中使用正则表达式来处理没有空格的数学表达式。这样，我们就能够处理没有空格的数学表达式，得到正确的解析树。