Question

在Edit-1上查看更新的输入和输出数据。

我想要完成的是转向

+ 1
 + 1.1
  + 1.1.1
   - 1.1.1.1
   - 1.1.1.2
 + 1.2
  - 1.2.1
  - 1.2.2
 - 1.3
+ 2
- 3

进入python数据结构，如

[{'1': [{'1.1': {'1.1.1': ['1.1.1.1', '1.1.1.2']}, '1.2': ['1.2.1', '1.2.2']}, '1.3'], '2': {}}, ['3',]]

我查看过许多不同的wiki标记语言，降价标记，重组文本等等，但是它们对我理解它是如何工作非常复杂，因为它们必须覆盖大量的标记和语法（我只需要“列出”其中大部分的部分，但当然转换为python而不是html。）

我还看了一下tokenizer，词法分析器和解析器，但是它们比我需要的要复杂得多，而且我能理解。

我不知道从哪里开始，并希望对此主题提供任何帮助。感谢

编辑-1 ：是的，行开头的字符很重要，从之前的所需输出开始，现在可以看出 * 表示带子节点的根节点， + 有子节点， - 没有子节点（root或其他），只是与该节点有关的额外信息。 * 并不重要，可以与 + 互换（我可以通过其他方式获取root状态。）

因此，新要求仅使用 * 来表示有或没有孩子的节点， - 不能有孩子。我也改变了它，所以关键不是 * 之后的文字，因为这无疑会更改为实际的标题。

例如

* 1
 * 1.1
 * 1.2
  - Note for 1.2
* 2
* 3
- Note for root

会给出

[{'title': '1', 'children': [{'title': '1.1', 'children': []}, {'title': '1.2', 'children': []}]}, {'title': '2', 'children': [], 'notes': ['Note for 1.2', ]}, {'title': '3', 'children': []}, 'Note for root']

或者如果你有另一个想法在python中表示大纲，那么就把它推进去。

Answer 1

编辑：由于我编辑了代码的规范中的说明和更改，仍然使用显式Node类作为清晰的中间步骤 - 逻辑是将行列表转换为节点列表，然后将该节点列表转换为树（通过适当地使用它们的缩进属性），然后以可读形式打印该树（这只是一个“调试 - 帮助”步骤，到检查树是否构造良好，并且当然可以在脚本的最终版本中进行注释 - 当然，它将从文件中获取行而不是将它们硬编码以进行调试！ - ），最后构建所需的Python结构并打印出来。这是代码，正如我们将看到的那样，结果是几乎，因为OP指定了一个例外 - 但是，代码首先：

import sys

class Node(object):
  def __init__(self, title, indent):
    self.title = title
    self.indent = indent
    self.children = []
    self.notes = []
    self.parent = None
  def __repr__(self):
    return 'Node(%s, %s, %r, %s)' % (
        self.indent, self.parent, self.title, self.notes)
  def aspython(self):
    result = dict(title=self.title, children=topython(self.children))
    if self.notes:
      result['notes'] = self.notes
    return result

def print_tree(node):
  print ' ' * node.indent, node.title
  for subnode in node.children:
    print_tree(subnode)
  for note in node.notes:
    print ' ' * node.indent, 'Note:', note

def topython(nodelist):
  return [node.aspython() for node in nodelist]

def lines_to_tree(lines):
  nodes = []
  for line in lines:
    indent = len(line) - len(line.lstrip())
    marker, body = line.strip().split(None, 1)
    if marker == '*':
      nodes.append(Node(body, indent))
    elif marker == '-':
      nodes[-1].notes.append(body)
    else:
      print>>sys.stderr, "Invalid marker %r" % marker

  tree = Node('', -1)
  curr = tree
  for node in nodes:
    while node.indent <= curr.indent:
      curr = curr.parent
    node.parent = curr
    curr.children.append(node)
    curr = node

  return tree


data = """\
* 1
 * 1.1
 * 1.2
  - Note for 1.2
* 2
* 3
- Note for root
""".splitlines()

def main():
  tree = lines_to_tree(data)
  print_tree(tree)
  print
  alist = topython(tree.children)
  print alist

if __name__ == '__main__':
  main()

运行时，会发出：

 1
  1.1
  1.2
  Note: 1.2
 2
 3
 Note: 3

[{'children': [{'children': [], 'title': '1.1'}, {'notes': ['Note for 1.2'], 'children': [], 'title': '1.2'}], 'title': '1'}, {'children': [], 'title': '2'}, {'notes': ['Note for root'], 'children': [], 'title': '3'}]

除了键的排序（当然是无关紧要且无法保证在dict中），这是几乎按要求 - 除了所有备注显示为带有notes键的dict条目和一个字符串列表的值（如果列表为空，则省略注释条目，大致与问题中的示例一样）。

在当前版本的问题中，如何表示笔记有点不清楚;一个注释显示为独立字符串，其他注释显示为值为字符串的条目（而不是我正在使用的字符串列表）。目前尚不清楚是什么意味着该音符必须在一个案例中作为独立字符串出现，在所有其他案例中作为dict条目出现，所以我使用的这个方案更加规则;如果一个音符（如果有的话）是单个字符串而不是一个列表，那么这是否意味着如果一个节点出现多个音符则会出错？在后一方面，我使用的这个方案更通用（让一个节点从0开始有任意数量的音符，而不是在问题中明显暗示的0或1）。

编写了这么多代码（预编辑答案大约有一段时间并帮助澄清和更改规格）以提供（我希望）99％的所需解决方案，我希望这能满足原始海报，因为最后一个对代码和/或规范进行一些调整以使它们相互匹配应该很容易让他做到！

Answer 2

由于您正在处理大纲情况，因此可以使用堆栈简化操作。基本上，您希望创建一个堆栈，其中dict s对应于轮廓的深度。解析新行并且轮廓的深度增加时，将新的dict推送到堆栈顶部的前一个dict引用的堆栈上。解析具有较低深度的行时，会弹出堆栈以返回到父级。当您遇到具有相同深度的行时，将其添加到堆栈顶部的dict。

Answer 3

在解析树时，堆栈是一个非常有用的数据结构。您只需保持从最后添加的节点到堆栈上的根的路径，这样您就可以通过缩进的长度找到正确的父节点。这样的东西应该可以解析你的上一个例子：

import re
line_tokens = re.compile('( *)(\\*|-) (.*)')

def parse_tree(data):
    stack = [{'title': 'Root node', 'children': []}]
    for line in data.split("\n"):
        indent, symbol, content = line_tokens.match(line).groups()        
        while len(indent) + 1 < len(stack):
            stack.pop() # Remove everything up to current parent
        if symbol == '-':
            stack[-1].setdefault('notes', []).append(content)
        elif symbol == '*':
            node = {'title': content, 'children': []}
            stack[-1]['children'].append(node)
            stack.append(node) # Add as the current deepest node
    return stack[0]

Answer 4

您使用的语法是非常类似于Yaml。它有一些差异，但它很容易学习 - 它的主要焦点是人类可读（和可写）。

看看Yaml网站。那里有一些python绑定，文档和其他内容。

http://www.yaml.org

如何解析标记的文本以进行进一步处理？

4 个答案: