Skip to main content
 首页 » 编程设计

python之使用 dump() 和 asXML() 函数时 pyparsing 不同的结果

2024年10月25日8sharpest

我在使用 pyparsing 解析结果时遇到问题。我有一个语法来解析一个表达式。在语法中的每个规则中都有 setResultName() 函数,因此我可以轻松地操作解析结果。但是当使用 dump() 函数查看结果的组织方式时,它不会显示所有解析的结果。但是,当使用 asXML() 函数时,所有结果都在那里并且按照我想要的方式构建。

语法如下:

# Rule for any alphanumeric word 
identifier = Word(alphas, alphas + nums) 
 
# Rule for "e" in floating point numbers 
e = CaselessLiteral('E') 
 
# Rule for booleans 
boolean = (Keyword('True')  
           | Keyword('False') 
).setParseAction(lambda tokens: bool(tokens[0])).setResultsName("boolean") 
 
# Rule for integer numbers 
integer = Word(nums).setParseAction(lambda tokens: int(tokens[0])) 
 
# Rule for factor operator 
factor_operator = (Literal('*')  
                   | Literal('/')  
                   | Literal('%') 
).setResultsName("operator") 
 
# Rule for term operator 
term_operator = (Literal('+')  
                 | Literal('-') 
).setResultsName("operator") 
 
# Rule for double numbers 
double = Combine(integer + 
                 Optional(Literal('.') + Optional(integer)) + 
                 Optional(e + Optional(term_operator) + integer) 
).setParseAction(lambda tokens: float(tokens[0])).setResultsName("double") 
 
# Forwarding expression rule 
expression = Forward() 
 
# Rule define type of factor 
factor = Group(( 
          Literal('(').suppress() +  
              expression.setResultsName("expression") + 
          Literal(')').suppress()) 
          | double  
          | boolean 
).setResultsName("factor") 
 
# Rule for factors 
factors = Group(ZeroOrMore(factor_operator + factor)).setResultsName("factors") 
 
# Rule for term 
term = Forward() 
term << Group(factor + delimitedList(factors)).setResultsName("term") 
 
# Rule for terms 
terms = Group(ZeroOrMore(term_operator + term)).setResultsName("terms") 
 
# Rule for expression 
expression << Group(Optional(term_operator) + term + delimitedList(terms) 
).setResultsName("expression") 
 
return expression 

这是我要解析的表达式:

"(2 * 3) + 20 / 5 - 1"

这里是 dump() 的输出:

[[[[[[[2.0], ['*', [3.0]]], []]], []], ['+', [[20.0], ['/', [5.0]]], '-', [[1.0], []]]]] 
- expression: [[[[[[2.0], ['*', [3.0]]], []]], []], ['+', [[20.0], ['/', [5.0]]], '-', [[1.0], []]]] 
  - term: [[[[[2.0], ['*', [3.0]]], []]], []] 
    - factor: [[[[2.0], ['*', [3.0]]], []]] 
      - expression: [[[2.0], ['*', [3.0]]], []] 
        - term: [[2.0], ['*', [3.0]]] 
          - factor: [2.0] 
            - double: 2.0 
          - factors: ['*', [3.0]] 
            - factor: [3.0] 
              - double: 3.0 
            - operator: * 
        - terms: [] 
    - factors: [] 
  - terms: ['+', [[20.0], ['/', [5.0]]], '-', [[1.0], []]] 
    - operator: - 
    - term: [[1.0], []] 
      - factor: [1.0] 
        - double: 1.0 
      - factors: [] 

以及 asXML() 的输出:

<expression> 
  <expression> 
    <term> 
      <factor> 
        <double>2.0</double> 
      </factor> 
      <factors> 
        <operator>*</operator> 
        <factor> 
          <double>3.0</double> 
        </factor> 
      </factors> 
    </term> 
    <terms> 
      <operator>-</operator> 
      <term> 
        <factor> 
          <double>20.0</double> 
        </factor> 
        <factors> 
          <operator>/</operator> 
          <factor> 
            <double>5.0</double> 
          </factor> 
        </factors> 
      </term> 
      <operator>+</operator> 
      <term> 
        <factor> 
          <double>1.0</double> 
        </factor> 
        <factors> 
        </factors> 
      </term> 
    </terms> 
  </expression> 
</expression> 

问题出在带括号的嵌套表达式之后的术语标签上。在 xml 中,它显示其中的所有术语(即“+”、“20.0/5.0”、“-”、“1.0”),这应该是一个运算符和术语列表。使用 dump() 函数时,它仅显示最后一个运算符和术语(即“-”、“1.0”)。 谁能帮我理解这个?有什么我想念的吗?抱歉,我没有说清楚。

请您参考如下方法:

如果 dump() 和 asXML() 之间存在差异,我更可能将其视为 asXML() 中的错误>。该方法被迫对需要的内容进行相当多的“猜测”,在某些情况下我很容易看出它猜错了。

pyparsing 的默认行为是将所有已解析的标记作为一个简单的字符串列表返回。无论解析器是如何构建的,它都会这样做。这是为了

(A + B + C).parseString 
 
AA = A + B 
(AA + C).parseString 
 
and 
 
DD = B + C 
(A + DD).parseString 

所有返回相同的东西。

让我们看一个简单的语法,名字/年龄对的倍数:

test = "Bob 10 Sue 12 Henry 7" 

这是我们的解析器:

name = Word(alphas) 
integer = Word(nums) 
 
parser = OneOrMore(name + integer) 
 
# or you can use the new multiplication syntax 
parser = (name + integer) * (1,) 

使用给定的示例文本和上述解析器,这将是:

['Bob', '10', 'Sue', '12', 'Henry', '7'] 

现在这并不难走完,一次阅读两个项目。但是,如果有额外的可选字段,那么事情就会变得更加棘手。因此,告诉 pyparsing 每个人的姓名和年龄应该分组在一起要容易得多。

parser = OneOrMore(Group(name + integer)) 

现在我们得到了每个人的子列表,并且无需猜测是否可能有其他选项。

[['Bob', '10'], ['Sue', '12'], ['Henry', '7']] 

如果您将结果名称添加到原始未分组的解析器,我们会看到这一点(我使用的是"new"可调用语法,而不是冗长且令人分心的“setResultsName”调用格式):

parser = OneOrMore(name("name") + integer("age")) 
result = parser.parseString(test) 

了解我们现在对未分组结果的了解,如果我们要求 result.name,我们应该得到哪个名称?

如果您遇到多个表达式共享相同结果名称的情况,那么您有 3 个选项:

  • 只保留最后一个被解析(默认,这就是你所看到的)

  • 使用 Group 类添加分组,以便将多个共享结果分成不同的子结构

  • 将 listAllItems=True 参数添加到 setResultsName()

    parser = (OneOrMore(name.setResultsName("name", listAllItems=True) 
              + integer.setResultsName("age", listAllItems=True))) 
    

    或者如果使用缩写的可调用格式,请在结果名称的末尾添加“*”:

    parser = OneOrMore(name("name*") + integer("age*")) 
    

现在 result.name 将为您提供列表中所有已解析的名称,result.age 将为您提供相应的年龄。但对于这样的数据,我更愿意看到数据被解析成组。

parser = OneOrMore(Group(name("name") + integer("age"))) 

如果您希望 asXML() 使用标签“person”来标记每个组,然后将该名称添加到组中,并使用尾随的“*”来捕获所有组。

parser = OneOrMore(Group(name("name") + integer("age"))("person*") 

(这已经是一个冗长的答案,所以我省略了这些测试的 dump() 和 asXML() 输出 - 留作 OP 和 future 读者的练习。)