Python 将递归计算器重构为迭代计算器

我有一个Django应用程序，它是一个计算器。用户在一个屏幕上配置任意深度的计算（比如Excel公式），然后在另一个屏幕上输入（单元格）数据

在将字段链接到它们的值之后，我得到了一个如下的公式

SUM(1,2,4)

可以任意深，例如

SUM(1,SUM(5,DIFFERENCE(6,DIVISION(8,10),7),4),2)

让我头疼的一个公式是用户在我们系统中输入的一个更复杂的公式：

ROUND(MULTIPLICATION(DIVISION(ROUND(SUM(MULTIPLICATION(50.00000,50.00000),MULTIPLICATION(50.00000,50.00000,2),MULTIPLICATION(50.00000,50.00000)),-2),300),DIFFERENCE(DIFFERENCE(41,7),0.3)),0)

我使用pyparsing来解析公式，提取值和嵌套公式，并递归地执行计算。问题是，由于解析每个嵌套计算，我在pyparsing中遇到了递归限制

我的递归代码：

class Calculator:
def __init__(self, formula=None):
    self.formula = formula

def do_calculation(self):
    # parse the formula we receive, which returns arguments in groups of numbers and nested calculations
    # e.g. SUM(MULTIPLICATION(12,11),1,5)
    parsed_formula = FormulaParser(self.formula).get_parsed_formula()

    #calculation name is the outermost level calculation
    calc_name = parsed_formula['calculation_name']
    #don't stomp on built in round
    if 'ROUND' in "".join(calc_name):
        calc_name = ["ROUND_CALCULATION"]
    #don't stomp on if
    if 'IF' == "".join(calc_name):
        calc_name = ['IF_STATEMENT']
    #grab the name of the calculation, will match a function name below
    ex = getattr(self, string.lower("".join(calc_name)))
    calc_arguments = []
    #formulas need to be recursively executed
    formulas = parsed_formula.args.formulas.asList() if len(parsed_formula.args.formulas) else []
    #numbers are just added to the arguments
    dnumbers = parsed_formula.args.dnumbers.asList() if len(parsed_formula.args.dnumbers) else []

    for arg in parsed_formula.args.asList():
        if arg in dnumbers:
            calc_arguments.append(''.join(arg))
        elif arg in formulas:
            new_calc = Calculator(''.join(self.flatten(arg[:])))
            calc_arguments.append(new_calc.do_calculation())

    #execute the calculation with the number arguments
    for idx, arg in enumerate(calc_arguments):
        if isinstance(arg, dict) and arg['rounding']:
            calc_arguments[idx] = arg['result']
    result = ex(*calc_arguments)
    #for rounding, output is special to tell the api to not format to default 5 decimal places
    if 'ROUND' in "".join(calc_name):
        return dict(result=result, rounding=True)
    return result

# function called on nested calculations that may have other nested calculations to flatten to a single level list
@staticmethod
def flatten(expr):
    for i, x in enumerate(expr):
        while isinstance(expr[i], list):
            expr[i:i + 1] = expr[i]
    return expr

以及公式的解析器：

class FormulaParser():
def __init__(self, formula=None):
    self.formula = formula

    # grammar
    # end result
    expr = Forward()
    formula = Forward()

    #calculation keywords
    calc_keyword = lambda name: Keyword(name)
    calculations = [calc_keyword(calc) for calc in CALCULATION_TYPES]
    calc_name = Group(reduce(lambda y, z: y | z, [x for x in calculations])).setResultsName('calculation_name')

    #symbols
    oparen, cparen, comma, dot, minus = map(Literal, '(),.-')
    dnumber = Combine(Optional(minus) + Word(nums) + Optional(dot + Word(nums)))

    #possible formulas
    expr = Group(formula).setResultsName('formulas', listAllMatches=True) | Group(dnumber).setResultsName(
        'dnumbers', listAllMatches=True)
    exprs = expr + ZeroOrMore(comma + expr)

    #entire formula
    formula << Combine(calc_name + Group(oparen + exprs + cparen).setResultsName('args'))
    self.parsed_formula = formula

def get_parsed_formula(self):
    if self.formula:
        return self.parsed_formula.parseString(self.formula)

    return None

class FormulaParser（）：
定义初始化（self，公式=None）：
self.formula=公式
#文法
#最终结果
expr=Forward（）
公式=前进（）
#计算关键字
计算关键字=lambda名称：关键字（名称）
计算=[calc_关键字（calc）用于计算类型中的计算]
calc_name=Group（reduce（lambda y，z:y|z，[x代表计算中的x]）。setResultsName（'calculation_name'））
#象征
oparen，cparen，逗号，点，减号=映射（文字，，（），.-）
dnumber=组合（可选（减）+字（nums）+可选（点+字（nums）））
#可能的公式
expr=Group（formula）.setResultsName（'formulas'，listalMatches=True）| Group（dnumber）.setResultsName(
“dnumbers”，listAllMatches=True）
exprs=expr+ZeroOrMore（逗号+expr）
#完整公式
公式我不确定这是否能帮助您在解析堆栈中递归。如果您只想对表达式求值，那么您可以使用解析操作处理所有事情，并在解析时进行求值。请参阅my mods中嵌入的注释，以查看您提供的源代码：

sample = """ROUND(MULTIPLICATION(DIVISION(ROUND(SUM(MULTIPLICATION(50.00000,50.00000),MULTIPLICATION(50.00000,50.00000,2),MULTIPLICATION(50.00000,50.00000)),-2),300),DIFFERENCE(DIFFERENCE(41,7),0.3)),0)"""

from pyparsing import *

CALCULATION_TYPES = "ROUND MULTIPLICATION DIVISION SUM DIFFERENCE".split()

functionMap = {
    "ROUND"          : lambda args: round(args[0]),
    "MULTIPLICATION" : lambda args: args[0]*args[1],
    "DIVISION"       : lambda args: args[0]/args[1],
    "SUM"            : lambda args: args[0]+args[1],
    "DIFFERENCE"     : lambda args: args[0]-args[1],
    }

class FormulaParser():
    def __init__(self, formula=None):
        self.formula = formula

        # grammar
        # end result
        expr = Forward()
        formula = Forward()

        #calculation keywords
        calc_keyword = lambda name: Keyword(name)
        calculations = [calc_keyword(calc) for calc in CALCULATION_TYPES]
        calc_name = Group(reduce(lambda y, z: y | z, [x for x in calculations])).setResultsName('calculation_name')

        # a simpler way to create a MatchFirst of all your calculations
        # also, save the results names for when you assemble small elements into larger ones
        calc_name = MatchFirst(calculations)

        #symbols
        oparen, cparen, comma, dot, minus = map(Literal, '(),.-')
        #dnumber = Combine(Optional(minus) + Word(nums) + Optional(dot + Word(nums)))
        # IMPORTANT - convert numbers to floats at parse time with this parse action
        dnumber = Regex(r'-?\d+(\.\d+)?').setParseAction(lambda toks: float(toks[0]))

        #possible formulas
        #expr = Group(formula).setResultsName('formulas', listAllMatches=True) |
        #       Group(dnumber).setResultsName('dnumbers', listAllMatches=True)
        #exprs = expr + ZeroOrMore(comma + expr)

        #entire formula
        #formula << Combine(calc_name + Group(oparen + exprs + cparen).setResultsName('args'))
        #self.parsed_formula = formula

        # define what is allowed for a function arg
        arg_expr = dnumber | formula
        def eval_formula(tokens):
            fn = functionMap[tokens.calculation_name]
            return fn(tokens.args)

        # define overall formula, and add results names here
        formula <<= (calc_name("calculation_name") + oparen 
                                        + Optional(delimitedList(arg_expr))('args') 
                                        + cparen).setParseAction(eval_formula)
        self.parsed_formula = formula


    def get_parsed_formula(self):
        if self.formula:
            return self.parsed_formula.parseString(self.formula)

        return None

fp = FormulaParser(sample)
print fp.get_parsed_formula()

sample=“”四舍五入（乘法（除法）（四舍五入（和）（乘法（50.00000,50.00000），乘法（50.00000,50.00000,2），乘法（50.00000,50.00000）），-2），300），差（差（41,7），0.3）），0“
从pyparsing导入*
计算\u TYPES=“四舍五入乘法除法和差”.split（）
函数映射={
“圆形”：lambda参数：圆形（参数[0]），
“乘法”：lambda args:args[0]*args[1]，
“除法”：lambda args:args[0]/args[1]，
“总和”：lambda args:args[0]+args[1]，
“差异”：lambda args:args[0]-args[1]，
}
类FormulaParser（）：
定义初始化（self，公式=None）：
self.formula=公式
#文法
#最终结果
expr=Forward（）
公式=前进（）
#计算关键字
计算关键字=lambda名称：关键字（名称）
计算=[calc_关键字（calc）用于计算类型中的计算]
calc_name=Group（reduce（lambda y，z:y|z，[x代表计算中的x]）。setResultsName（'calculation_name'））
#创建匹配的更简单方法首先是计算
#另外，保存结果名称，以便在将小图元组合成较大图元时使用
计算名称=匹配优先（计算）
#象征
oparen，cparen，逗号，点，减号=映射（文字，，（），.-）
#dnumber=组合（可选（减）+字（nums）+可选（点+字（nums）））
#要点-使用此解析操作在解析时将数字转换为浮点数
dnumber=Regex（r'-？\d+（\.\d+））.setParseAction（lambda-toks:float（toks[0]））
#可能的公式
#expr=Group（formula）.setResultsName（'formulas'，listAllMatches=True）|
#组（dnumber）.setResultsName（'dnumbers'，listAllMatches=True）
#exprs=expr+ZeroOrMore（逗号+expr）
#完整公式
#谢谢。这是一个很好的解决方案。最后，我决定不把担忧混为一谈。我想得太多了。我将解析器简化为我感兴趣的标记，并使用一个简单的堆栈实现来进行计算。