比循环和调用循环和调用其他函数的函数更好的方法

Question

I have a message (string) that is composed of transactions that is composed of groups that is composed of elements .

I there a better way to parse such message than looping and calling functions that loop and call another functions that loop and call another functions because I find the following is silly:

class Parser:
  def parse_msg(self, msg):
    trans = re.findall(trans_pattern, msg)
    for t in trans:
      self.parse_trans(t)

  def parse_trans(self, trans):
    groups = re.findall(groups_pattern, trans)
    for g in groups:
      self.parse_group(g)

  def parse_group(self, group):
    elements = re.findall(element_pattern, group)
    for e in elements:
      self.parse_element(e)

  def parse_element(self, e):
    pass

Is there a better way/ design-pattern that I can approach this with?

Answer 1

Well, I guess there are several possibilities. You could have some structure like the following:

import re

GRAMMAR = (
    trans_pattern, (
        groups_pattern, (
            element_pattern, None
        )
    )
)

def parse_message(msg):
    parse_message_rec(msg, GRAMMAR)

def parse_message_rec(msg, grammar):
    if grammar is None:
        # Leaf element
        return
    pattern, next_grammar = grammar
    children = re.findall(pattern, msg)
    for child in children:
        parse_message_rec(child, next_grammar)

Answer 2

That method definitely sounds intensive since every bit of text will be gone over multiple times. O(n^3) complexity or something.

Instead, I would create a function to go through the input once and have it all parsed in one shot. To do that, it sounds like there's a handy pyparsing module you can use (I've never used it myself so I'm not sure of the learning curve, difficulty, or optimization). Otherwise, to do it manually, you'd have to keep track of your current "depth" (trans, group, or element) and determine if you're closing or opening a trans/group/element at that depth while keeping track of the data between opening and closing expressions. In short, don't find all "trans", just find where the first one begins, grab any unique data up until the next group begins, start the new group, grab unique data until the element begins, start the new element, grab data until it closes, see if there's another element or if the group closes, etc, etc. Not as concise, but certainly faster. If speed is not a concern, your method is fine. If it is (or will be) a concern, then you'll want to parse it in one pass.

Answer 3

我命令您使用以下方法：将特殊格式转换为简单XML（使用正则表达式或您喜欢的格式），然后您可以应用任何XML模式/方法/库来解析文本。