将自定义公式转换为python函数[重复]

Question

考虑我们有以下输入

formula = "(([foo] + [bar]) - ([baz]/2) )"

function_mapping = {
                   "foo" : FooFunction,
                   "bar" : BarFunction,
                   "baz" : BazFunction,  
                  }

是否有任何 python 库可以让我解析公式并将其转换为 python 函数表示。

例如。

converted_formula = ((FooFunction() + BarFunction() - (BazFunction()/2))

我目前正在研究类似的东西

In [11]: ast = compiler.parse(formula)

In [12]: ast
Out[12]: Module(None, Stmt([Discard(Sub((Add((List([Name('foo')]), List([Name('bar')]))), Div((List([Name('baz')]), Const(2))))))]))

然后进一步处理这个 ast 树。

您知道任何更清洁的替代解决方案吗？ 非常感谢任何帮助或见解！

Answer 1

您可以使用re 模块通过正则表达式模式匹配和相对简单的文本替换来做您想做的事情。

import re

alias_pattern = re.compile(r'''(?:\[(\w+)\])''')

def mapper(mat):
    func_alias = mat.group(1)
    function = function_alias_mapping.get(func_alias)
    if not function:
        raise NameError(func_alias)
    return function.__name__ + '()'

# must be defined before anything can be mapped to them
def FooFunction(): return 15
def BarFunction(): return 30
def BazFunction(): return 6

function_alias_mapping =  dict(foo=FooFunction, bar=BarFunction, baz=BazFunction)
formula = "(([foo] + [bar]) - ([baz]/2))"  # Custom formula.

converted_formula = re.sub(alias_pattern, mapper, formula)
print('converted_formula = "{}"'.format(converted_formula))

# define contexts and function in which to evalute the formula expression
global_context = dict(FooFunction=FooFunction,
                      BarFunction=BarFunction,
                      BazFunction=BazFunction)
local_context = {'__builtins__': None}

function = lambda: eval(converted_formula, global_context, local_context)
print('answer = {}'.format(function()))  # call function

输出：

converted_formula = "((FooFunction() + BarFunction()) - (BazFunction()/2))"
answer = 42

Answer 2

您可以使用所谓的字符串格式化来完成此操作。

function_mapping = {
                   "foo" : FooFunction(),
                   "bar" : BarFunction(),
                   "baz" : BazFunction(),  
                  }

formula = "(({foo} + {bar}) - ({baz}/2) )".format( **function_mapping )

会给你((FooFunction() + BarFunction() - (BazFunction()/2))的结果

但我相信这些函数会在加载模块时执行，所以也许更好的解决方案是

function_mapping = {
                   "foo" : "FooFunction",
                   "bar" : "BarFunction",
                   "baz" : "BazFunction",  
                  }

formula = "(({foo}() + {bar}()) - ({baz}()/2) )".format( **function_mapping )

这将为您提供字符串'((FooFunction() + BarFunction() - (BazFunction()/2))'，然后您可以随时使用eval 函数执行该字符串。

Answer 3

如果您稍微更改公式中使用的语法，（另一种）方法（正如我在comment 中提到的那样）将使用string.Template 替换。

出于好奇，我决定找出这种其他方法是否可行——因此能够提出更好的答案，因为它不仅比我的 other 更简单，而且更灵活一点从某种意义上说，向被调用的函数添加参数很容易，如下面的评论中所述。

from string import Template

def FooFunction(): return 15
def BarFunction(): return 30
def BazFunction(): return 6

formula = "(($foo + $bar) - ($baz/2))"

function_mapping = dict(foo='FooFunction()',  # note these calls could have args
                        bar='BarFunction()',
                        baz='BazFunction()')

converted_formula = Template(formula).substitute(function_mapping)
print('converted_formula = "{}"'.format(converted_formula))

# define contexts in which to evalute the expression
global_context = dict(FooFunction=FooFunction,
                      BarFunction=BarFunction,
                      BazFunction=BazFunction)
local_context = dict(__builtins__=None)
function = lambda: eval(converted_formula, global_context, local_context)

answer = function()  # call it
print('answer = {}'.format(answer))

作为最后一点，请注意string.Template 支持不同类型的高级用法，这将允许您进一步微调表达式语法——因为它在内部使用re 模块（比我在原始答案中所做的更复杂）。

对于映射函数的所有返回值都可以表示为 Python 字面量（如数字）的情况，并且不会仅仅因为它们产生的副作用而被调用，您可以进行以下修改以有效缓存（又名memoize) 结果：

function_cache = dict(foo=FooFunction(),  # calls and caches function results
                      bar=BarFunction(),
                      baz=BazFunction())

def evaluate(formula):
    print('formula = {!r}'.format(formula))
    converted_formula = Template(formula).substitute(function_cache)
    print('converted_formula = "{}"'.format(converted_formula))
    return eval(converted_formula, global_context, local_context)

print('evaluate(formula) = {}'.format(evaluate(formula)))

输出：

formula = '(($foo + $bar) - ($baz/2))'
converted_formula = "((15 + 30) - (6/2))"
evaluate(formula) = 42