pyparsing-如何使用比較運算符解析字符串？

Question

因此，我有一個NumericStringParser類（從此處提取），定義如下：

from __future__ import division
from pyparsing import Literal, CaselessLiteral, Word, Combine, Group, Optional, ZeroOrMore, Forward, nums, alphas, oneOf, ParseException
import math
import operator

class NumericStringParser(object):

    def __push_first__(self, strg, loc, toks):
        self.exprStack.append(toks[0])

    def __push_minus__(self, strg, loc, toks):
        if toks and toks[0] == "-":
            self.exprStack.append("unary -")

    def __init__(self):
        point = Literal(".")
        e = CaselessLiteral("E")
        fnumber = Combine(Word("+-" + nums, nums) +
                          Optional(point + Optional(Word(nums))) +
                          Optional(e + Word("+-" + nums, nums)))
        ident = Word(alphas, alphas + nums + "_$")
        plus = Literal("+")
        minus = Literal("-")
        mult = Literal("*")
        floordiv = Literal("//")
        div = Literal("/")
        mod = Literal("%")
        lpar = Literal("(").suppress()
        rpar = Literal(")").suppress()
        addop = plus | minus
        multop = mult | floordiv | div | mod
        expop = Literal("^")
        pi = CaselessLiteral("PI")
        tau = CaselessLiteral("TAU")
        expr = Forward()
        atom = ((Optional(oneOf("- +")) +
                 (ident + lpar + expr + rpar | pi | e | tau | fnumber).setParseAction(self.__push_first__))
                | Optional(oneOf("- +")) + Group(lpar + expr + rpar)
                ).setParseAction(self.__push_minus__)

        factor = Forward()
        factor << atom + \
            ZeroOrMore((expop + factor).setParseAction(self.__push_first__))
        term = factor + \
            ZeroOrMore((multop + factor).setParseAction(self.__push_first__))
        expr << term + \
            ZeroOrMore((addop + term).setParseAction(self.__push_first__))

        self.bnf = expr

        self.opn = {
            "+": operator.add,
            "-": operator.sub,
            "*": operator.mul,
            "/": operator.truediv,
            "//": operator.floordiv,
            "%": operator.mod,
            "^": operator.pow,
            "=": operator.eq,
            "!=": operator.ne,
            "<=": operator.le,
            ">=": operator.ge,
            "<": operator.lt,
            ">": operator.gt
            }

        self.fn = {
            "sin": math.sin,
            "cos": math.cos,
            "tan": math.tan,
            "asin": math.asin,
            "acos": math.acos,
            "atan": math.atan,
            "exp": math.exp,
            "abs": abs,
            "sqrt": math.sqrt,
            "floor": math.floor,
            "ceil": math.ceil,
            "trunc": math.trunc,
            "round": round,
            "fact": factorial,
            "gamma": math.gamma
            }

    def __evaluate_stack__(self, s):
        op = s.pop()
        if op == "unary -":
            return -self.__evaluate_stack__(s)
        if op in ("+", "-", "*", "//", "/", "^", "%", "!=", "<=", ">=", "<", ">", "="):
            op2 = self.__evaluate_stack__(s)
            op1 = self.__evaluate_stack__(s)
            return self.opn[op](op1, op2)
        if op == "PI":
            return math.pi
        if op == "E":
            return math.e
        if op == "PHI":
            return phi
        if op == "TAU":
            return math.tau
        if op in self.fn:
            return self.fn[op](self.__evaluate_stack__(s))
        if op[0].isalpha():
            raise NameError(f"{op} is not defined.")
        return float(op)

我有一個evaluate()函數，定義如下：

def evaluate(expression, parse_all=True):
    nsp = NumericStringParser()
    nsp.exprStack = []
    try:
        nsp.bnf.parseString(expression, parse_all)
    except ParseException as error:
        raise SyntaxError(error)
    return nsp.__evaluate_stack__(nsp.exprStack[:])

evaluate()是一個函數，它將解析字符串以計算數學運算，例如：

>>> evaluate("5+5")
10

>>> evaluate("5^2+1")
26

問題是它無法計算比較運算符（ = ， != ， < ， > ， <= ， >= ），並且當我嘗試： evaluate("5=5") ，它將引發SyntaxError: Expected end of text (at char 1), (line:1, col:2)而不是返回True 。 函數如何計算這六個比較運算符？

Answer 1

正如@rici指出的那樣，您已添加了評估部分，但未添加解析部分。

解析器在以下幾行中定義：

    factor = atom + \
        ZeroOrMore((expop + factor).setParseAction(self.__push_first__))
    term = factor + \
        ZeroOrMore((multop + factor).setParseAction(self.__push_first__))
    expr <<= term + \
        ZeroOrMore((addop + term).setParseAction(self.__push_first__))

這些語句的順序很重要，因為它們使解析器識別您在中學數學中學到的運算的優先級。 也就是說，乘冪最高，然后是乘法和除法，然后是加法和減法。

您需要按照相同的模式將關系運算符插入此解析器定義。 添加之后，來自C語言運算符優先級的約定（我找到此參考-https : //www.tutorialspoint.com/cprogramming/c_operators_precedence.htm ）為：

relational operations - <=, >=, >, <
equality operations - ==, !=

在您的情況下，您選擇使用'='而不是'=='，在這種情況下應該可以。 我建議您使用pyparsing的oneOf助手來定義這些運算符組，因為它將處理短字符串可能掩蓋較長字符串的情況（例如，在上一篇文章中'/'掩蓋了'//'）。

請注意，通過將所有這些操作混合到一個表達式解析器中，您將獲得5 + 2 > 3 。 由於'>'的優先級較低，因此將首先計算5 + 2並給出7，然后將評估7> 3，並且operator.__gt__將返回1或0。

將此示例擴展到其他運算符的困難是導致我在infixNotation編寫infixNotation helper方法的原因。 您可能想看看。

編輯：

您詢問有關使用Literal('<=') | Literal('>=) | etc. Literal('<=') | Literal('>=) | etc. Literal('<=') | Literal('>=) | etc. ，正如您所寫的那樣，它將正常工作。 您只需要注意要在較短的運算符之前尋找較長的運算符。 如果您寫Literal('>') | Literal('>=') | ... Literal('>') | Literal('>=') | ... Literal('>') | Literal('>=') | ...然后匹配'> ='將失敗，因為第一個匹配將匹配'>'，然后您將剩下'='。 使用oneOf可以幫助您解決此問題。

要添加其他解析器步驟，只需要對最后一級執行expr <<= ...步驟。 再次查看語句模式。 更改expr <<= term + etc. ，以arith_expr = term + etc. ，遵循它來添加水平relational_expr和equality_expr ，然后完成expr <<= equality_expr 。

此模式基於：

factor := atom (^ atom)...
term := factor (mult_op factor)...
arith_expr := term (add_op term)...
relation_expr := arith_expr (relation_op arith_expr)...
equality_expr := relation_expr (equality_op relation_expr)...

嘗試自行轉換為Python / pyparsing。

Answer 2

factor << atom + \
    ZeroOrMore((expop + factor).setParseAction(self.__push_first__))
term = factor + \
    ZeroOrMore((multop + factor).setParseAction(self.__push_first__))
arith_expr = term + \
    ZeroOrMore((addop + term).setParseAction(self.__push_first__))
relational = arith_expr + \
    ZeroOrMore((diffop + arith_expr).setParseAction(self.__push_first__))
expr <<= relational + \
    ZeroOrMore((compop + relational).setParseAction(self.__push_first__))

所以我測試了，它有效！ 非常感謝PaulMcG！ :)