Python 在pyparsing中正确使用nestedExpr

我有一个键值对的嵌套表示，类似：
案例1：

案例2：

str = " value { \
          {'name' {value 'joint'}}, 
          {'id' {value 51}} \
         }"

或案例3：

str = " value { \
           { 'drive' { value 'joint1'}}, \
           { 'steer' { value 45.35}}
         }"

可以看出，嵌套可以达到无限级别。e、 在上面的例子中，

'joint2'

也可以有花括号<代码>值是此处唯一的关键字。最后，值可以是整数、浮点或单引号字符串

我这里有一个非常简单的代码：

field_name = Keyword("value").supress()
real = Combine(Word(nums) + '.' + Word(nums))
values = real | Word(
    nums) | sglQuotedString.setParseAction(removeQuotes)

nested = nestedExpr('{', '}')
grammar = field_name + \
    (values | (nestedExpr('{', '}') + Optional(',').suppress()))("values")

对于案例2，我得到一个输出

{'values': [[["'name'", ['value', "'joint'"]], ',', ["'id'", ['value', '51']]]]}

首先，

，“

和

值也被解析。其次，我不确定是否正确使用了
nestedExpr
。我是否应该在
nestedExpr
内部使用
Dict

编辑1:
我已经发布了上述案例的解决方案，但我意识到案例2和3是相同的。我真正想展示的是

案例4：

str = "value { \
         {'name' {value 'joint1' { \
                           value 12} \
                                 } \
                 } \
         }, \
         {'id' {value 51}} \
       }"

对于这种情况，我是否需要知道嵌套的深度
 我找到了一个解决方案：

from pyparsing import *

_value = Keyword("value").suppress()
real = Combine(Word(nums) + '.' + Word(nums))
values = real | Word(
    nums) | sglQuotedString.setParseAction(removeQuotes)


LCB, RCB = map(Suppress, "{}")
param_val = _value + values
param_vals = Dict(OneOrMore(Group(sglQuotedString.setParseAction(
    removeQuotes) + nestedExpr('{', '}', content=param_val))))
param_values = _value + \
    nestedExpr('{', '}', content=delimitedList(
        LCB + param_vals + RCB, delim=','))

str = "value {{'name' {value 'arm_right_1_joint'}}, {'id' {value 51}}}"
res = param_values.parseString(str)

print(res.dump())

我得到的结果是：

[[['name', ['arm_right_1_joint']], ['id', ['51']]]]
[0]:
  [['name', ['arm_right_1_joint']], ['id', ['51']]]
  - id: ['51']
  - name: ['arm_right_1_joint']

请随时提出其他解决方案

编辑：
我找到了更好的解决办法。现在它可以解析任何级别的递归性

real = Combine(Word(nums) + '.' + Word(nums))

listStr = Forward()
mapStr = Forward()
param_value = Forward()

string_value = Dict(Group(sglQuotedString.setParseAction(
    removeQuotes) + ZeroOrMore(LCB + param_value + RCB)))
string_value.setParseAction(parseActionStr)
values = Combine(Optional("-") + real) | Combine(Optional("-") + Word(
    nums)) | string_value | Keyword("false") | Keyword("true") | listStr | mapStr
listStr << delimitedList(Group(LCB + delimitedList(values) + RCB))

mapStr << (LSB + delimitedList(Group(LCB + delimitedList((Group(sglQuotedString.setParseAction(removeQuotes) +
                                                                Suppress(":") + values))) + RCB)) + RSB)
mapStr.setParseAction(parseActionDict)

param_value << _value + (values | listStr)

它们是：

很好地使用了
Dict
来自动定义结果名称。我通常不鼓励使用
nestedExpr
，因为它不仅仅是为了匹配嵌套的打开/关闭分隔符（通常是为了在试图解析某个更大的表达式时跳过它们），而是为了添加内容定义，可能还可以。如果你用
pyparsing\u common.number
代替
real
和
Word（nums）
在
values中使用
pyparsing\u common.number，你会得到更快的解析正则表达式，并自动转换为实际的Python浮点和整数。谢谢@PaulMcG！！我仍然无法处理嵌套结构。有什么好办法吗？或者我需要事先知道我期望的嵌套级别是多少？对于无限嵌套，我们需要做一个更合适的递归解析器。使用
nestedExpr
可能是可行的，但是使用
Forward
编写显式递归程序将是更好的选择。在这一点上，我将后退一步，编写一个BNF，以澄清关于嵌套将如何进行的思考，然后将其转换回pyparsing/Python。
real = Combine(Word(nums) + '.' + Word(nums))

listStr = Forward()
mapStr = Forward()
param_value = Forward()

string_value = Dict(Group(sglQuotedString.setParseAction(
    removeQuotes) + ZeroOrMore(LCB + param_value + RCB)))
string_value.setParseAction(parseActionStr)
values = Combine(Optional("-") + real) | Combine(Optional("-") + Word(
    nums)) | string_value | Keyword("false") | Keyword("true") | listStr | mapStr
listStr << delimitedList(Group(LCB + delimitedList(values) + RCB))

mapStr << (LSB + delimitedList(Group(LCB + delimitedList((Group(sglQuotedString.setParseAction(removeQuotes) +
                                                                Suppress(":") + values))) + RCB)) + RSB)
mapStr.setParseAction(parseActionDict)

param_value << _value + (values | listStr)

str_param4 = "value { \
                  {'type' {value 'laser'}}, \
                  {'params' {value { \
                      {'upper_replacement_value' {value 10.0}}, \
                      {'use_message_range_limits' {value false}}, \
                      {'upper_threshold' {value 10.0}}}, \
                  {'name' {value 'range'}}}}}"

[['laser']]
[['range']]
[[[['type', 'laser']], [['params', [[['upper_replacement_value', '10.0']], [['use_message_range_limits', 'false']], [['upper_threshold', '10.0']]], [['name', 'range']]]]]]
[0]:
  [[['type', 'laser']], [['params', [[['upper_replacement_value', '10.0']], [['use_message_range_limits', 'false']], [['upper_threshold', '10.0']]], [['name', 'range']]]]]
  [0]:
    [['type', 'laser']]
    - type: 'laser'
  [1]:
    [['params', [[['upper_replacement_value', '10.0']], [['use_message_range_limits', 'false']], [['upper_threshold', '10.0']]], [['name', 'range']]]]
    - params: [[[['upper_replacement_value', '10.0']], [['use_message_range_limits', 'false']], [['upper_threshold', '10.0']]], [['name', 'range']]]
      [0]:
        [[['upper_replacement_value', '10.0']], [['use_message_range_limits', 'false']], [['upper_threshold', '10.0']]]
        [0]:
          [['upper_replacement_value', '10.0']]
          - upper_replacement_value: '10.0'
        [1]:
          [['use_message_range_limits', 'false']]
          - use_message_range_limits: 'false'
        [2]:
          [['upper_threshold', '10.0']]
          - upper_threshold: '10.0'
      [1]:
        [['name', 'range']]
        - name: 'range'