如何从字符串构造树？

Question

Input string: '(SBARQ (WHADVP (WRB Where)) (VBZ is) (NP (DT the) (NN cow)))'

This is the tree looks like:

Aims to build a TreeNode with label as node and all its covering string as value.

class TreeNode:
   def __init__(self):
        self.childre=[]
        self.label=""
        self.text=""

This is the what expected the tree looks like:

SBARQ: "Where is the cow"
WHADVP: "Where"
WRB: "Where"
VBZ: "is"
NP: "the cow"
DT: "the"
NN: "cow"

Answer 1

The main thing is to identify children. I'll try to explain my code:

class TreeNode:
    def __init__(self, string):
        
        self.im_leaf = string[0] != '('
        self.children = []

        if not self.im_leaf:
            first_space_index = string.index(" ")
            self.label = string[1:first_space_index]
            
            string = string[first_space_index + 1 : -1] #rest of the tree
            for node in self.split(string):
                self.children.append(TreeNode(node))
        else:
            self.label = string

        self.text = self.calculate_text()

    def calculate_text(self):
        if self.im_leaf:
            return self.label + ' '
        
        text = ''
        for node in self.children:
            text += node.calculate_text()

        return text


    def split(self, string):
        
        splitted = []
        pair_parenthesis = 0 
        index = 0

        for i in range(len(string)):
            char = string[i]

            if char == '(':
                pair_parenthesis += 1
            elif char == ')':
                pair_parenthesis -= 1
                if pair_parenthesis == 0:

                    new_node = string[index:i+1]
                    if new_node[0] == ' ':
                        new_node = new_node[1:]
                    splitted.append(new_node)
                    index = i + 1

        if len(splitted) == 0:  
            splitted = [string]
        
        return splitted

First, in __init__ I recognize if the given string describes a leaf which is determined by the first character, if it isn't a "open parenthesis" ( '(' ) then the current string describes a leaf,eg "cow" or Where ; differently to "not-leaf strings" such "(NP (DT the) (NN cow))" .

If string describes a leaf then label = string , else label is the substring between the first parenthesis (which is always in the first position) and the first white space. Also, in the latter case it is necessary to identify the different branches, which is done with the method split . Then, recursively the children are identified.

The split method identify the branches by counting open and closed parenthesis. Note that the first branch in "(WHADVP (WRB Where)) (VBZ is) (NP (DT the) (NN cow))" is (WHADVP (WRB Where)) , ie exactly when the number of open parenthesis is equal to the closed ones for the first time in the code (this difference is what is stored in pair_parenthesis ). The same occurs with the second and third branch. If a branch has only one child, for example "(WRB Where)" , the method will be called with the string "Where" , in those cases it returns "[Where]" .

Finally, text is assigned with the method calculate_text , which basically does recursive calls through the tree searching for leaves. If the node is a leaf, then its label is added to text .

Now some tests:

test_tree = TreeNode('(SBARQ (WHADVP (WRB Where)) (VBZ is) (NP (DT the) (NN cow)))')

print(test_tree.label)
#SBARQ

print(test_tree.text)
#Where is the cow 

print(test_tree.children[0].text) #text from the "WHADVP" node
#Where

Please let me know if something is not clear.

Answer 2

You could use recursion to create the tree and the aggregated texts simultaneously.

I would:

• Allow the constructor to be called with a label argument;
• Define the function, that creates a tree from a string, as a static method on your class;
• Use a regular expression to tokenise the input;
• Add some assert statements which would display readable exception messages when the input format is not as expected;
• Define __iter__ on your class, so that you can easily iterate over all the nodes that are present in the tree

import re

class TreeNode:
    def __init__(self, label=""):
        self.children = []
        self.label = label
        self.text = ""

    @staticmethod
    def create_from_string(text):
        tokens = re.finditer(r"[()]|[^\s()]+", text)
        match = next(tokens)
        token = match.group()
        assert token == "(", "Expected '(' at {}, but got '{}'".format(match.start(), token)

        def recur():
            node = None
            while True:
                match = next(tokens)
                i = match.start()
                token = match.group()
                if token == ")":
                    assert node, "Expected label at {}, but got ')'".format(i)
                    assert node.text, "Expected text at {}, but got ')'".format(i)
                    return node
                if token == "(":
                    assert node, "Expected label at {}, but got '('".format(i)
                    child = recur()
                    node.children.append(child)
                    token = child.text
                if node:
                    node.text = "{} {}".format(node.text, token).lstrip() 
                else:
                    node = TreeNode(token)

        return recur()

    def __iter__(self):
        def nodes():
            yield self
            for child in self.children:
                yield from child
        return nodes()

Here is how the above can be used for your concrete example:

s = '(SBARQ (WHADVP (WRB Where)) (VBZ is) (NP (DT the) (NN cow)))'
tree = TreeNode.create_from_string(s)
for node in tree:
    print("{}: {}".format(node.label, node.text))

This latter code will output:

SBARQ: Where is the cow
WHADVP: Where
WRB: Where
VBZ: is
NP: the cow
DT: the
NN: cow