python 分割和评估

Question

如何将一个字符串（带后缀）拆分为一个带括号的字符串？我的意思是，如果用户输入 3 (3 6 *) * 我希望解释器能够乘以 3 18 * 并理解文本中的括号。这可能吗？类似于 str.split() 但带有开始和结束分隔符？

难道我不现实吗？我发现 shlex 模块类似，但它只引用 AFAIK。

Answer 1

我不认为使用 re 是一个坏主意。您可以一次用其运算结果替换嵌套括号。对我来说似乎很简单：

import re
regex = re.compile(r'\([^\(\)]+\)')

def eval_expr(expr):
    match = regex.search(expr)
    if match:
        sub_expr = match.group()
        return eval_expr(expr.replace(sub_expr, str(eval_expr(sub_expr[1:-1]))))
    args = expr.split()
    op = args.pop()
    return eval(op.join(args))

并像这样使用：

>>> eval_expr('(1 (2 3 -) 4 +) (5 6 *) 7 +')
<<< 41

Answer 2

我对正则表达式不太熟悉。要求提供这个例子会不会太过分了？

正如克里斯的，呃，各种各样的评论所指出的，你不能有一个（真正的）正则表达式来解析嵌套括号。 （根据他的说法，有一些技巧和扩展可以扩展表达式语言，使其能够解析上下文无关语法。这是我第一次听说，但对我来说这听起来是个坏主意。 ）

这个答案似乎也有反对票......还有其他方法可以做到这一点吗？

阅读本文。

Answer 3

您可以编写一个 正则表达式 来提取带括号的子表达式。 re.split 可能会有所帮助，如果什么你关心的是在匹配的括号上分裂。一个简单的正则表达式可以让您挑选出子表达式。

#!/usr/bin/env python
import re
source = r"3 (3 6 *) *"
rewritten = source[:]
match_index = 1
snag_deepest = re.compile(r"""(?P<pre>.*)(?P<sub>\([^()]+\))(?P<post>.*)""")

print "Starting -> %s" % (rewritten)
results = snag_deepest.search(rewritten)
while results is not None:
    print "Subexpression %d -> %s" % (match_index, results.group('sub'))
    rewritten = "%s%s%s" % (results.group('pre'), "sub_%d" % match_index, results.group('post'))
    print "Rewritten as -> %s" % (rewritten)
    results = snag_deepest.search(rewritten)
    match_index += 1

产生

Starting -> 3 (3 6 *) *
Subexpression 1 -> (3 6 *)
Rewritten as -> 3 sub_1 *

Answer 4

首先，了解当运算符的元数已知时，后缀表示法中不需要括号。了解原因：

3 3 6 * *

从左侧开始，将操作数堆叠起来，直到遇到运算符：

operands <- 3 <- 3 <- 6
operator: *

我们知道 * 是二元运算符，因此从堆栈中弹出两个操作数，应用运算符，然后将结果推回on：

operands -> 3 -> 6
operands <- 18

继续累积操作数，直到遇到另一个运算符：

operator: *
operands -> 3 -> 18
operands <- 54

当表达式被使用时（假设其格式良好），堆栈将包含一个值：结果。

但你的问题是关于括号的：假设你的愿望是能够解析任意嵌套括号，正则表达式将无法帮助你，原因如下此处。您需要能够识别上下文无关语法的东西，即下推自动机。

但我认为，你正在寻找的不仅仅是抽象的计算机科学术语；而是更多的东西。 这里是一个相关问题，其中包含一些关于Shunting Yard 算法，将带括号的中缀表达式转换为后缀表达式。

编辑：好吧，我应该说“true正则表达式单独不会帮助你。”您可以使用正则表达式（匹配最里面的括号对）和替换（实际上）将括号表达式视为其自己的隐式解析树。但调车场算法更酷:)

Answer 5

如果我错了请纠正我，但你的表达是 RPD。如果是这样，则实际上不需要使用括号。请在下面找到我的示例（未优化并且很奇怪）：

import operator

def rpd_eval(expression):
    if expression.count('(') != expression.count(')'):
        return 0    
    expression = expression.replace(' ', '')
    ops = {'*': operator.mul, '**': operator.pow, '%': operator.mod,
           '+': operator.add, '-': operator.sub, '/': operator.div,
           '^': operator.pow}        
    res = []
    for v in list(expression):
        if not v in ops and v not in ['(',')']:
            res.append(int(v))
        elif v not in ['(',')']:
            b = float(res.pop())
            a = float(res.pop())
            res.append(ops[v](a, b))
    return res[0]

print rpd_eval('3(63*)*5+') # will print 59