Question

I have an algorithm to populate a tree like structure (class: Scan_instance_tree), but unfortunately, during each call, it is incorrectly adding to the root node’s children, as well as to the new child nodes created further down in the tree.

As a clue, I saw another thread…

Persistent objects in recursive python functions

…where this problem was mentioned briefly, and it was suggested that the parameters passed had to be mutable. Is that the answer, and how would I do this, in this example???

Here is my current code:

class Field_node(object):
    field_phenotype_id = -1
    field_name = ''
    field_parent_id = -1
    child_nodes = []          


class Scan_instance_tree(object):
    root_node = None  

    def __init__(self, a_db):
        self.root_node = Field_node()
        scan_field_values = self.create_scan_field_values(a_db)   # This just creates a temporary user-friendly version of a database table    
        self.build_tree(scan_field_values)  

    def build_tree(self, a_scan_field_values):
        self.root_node.field_name = 'ROOT'      
        self.add_child_nodes(a_scan_field_values, self.root_node)


    def add_child_nodes(self, a_scan_field_values, a_parent_node):
        i = 0
        while i < len(a_scan_field_values):
            if a_scan_field_values[i]['field_parent_dependancy'] == a_parent_node.field_phenotype_id:
                #highest_level_children.append(a_scan_field_values.pop(a_scan_field_values.index(scan_field))) 
                child_node = Field_node()
                child_node.field_phenotype_id = a_scan_field_values[i]['field_phenotype_id']
                child_node.field_name = a_scan_field_values[i]['field_name']
                child_node.field_parent_dependancy = a_scan_field_values[i]['field_parent_dependancy']

                a_parent_node.child_nodes.append(child_node)
                a_scan_field_values.remove(a_scan_field_values[i])

                # RECURSION: get the child nodes
                self.add_child_nodes(a_scan_field_values, child_node)
            else: 
                i = i+1

If I remove the recursive call to self.add_child_nodes(…), the root’s children are added correctly, ie they only consist of those nodes where the field_parent_dependancy = -1
If I allow the recursive call, the root’s children contain all the nodes, regardless of the field_parent_dependancy value.

Best regards

Ann

Answer 1

When you define your Field_node class, the line

    child_nodes = []

is actually instantiating a single list as a class attribute, rather than an instance attribute, that will be shared by all instances of the class.

What you should do instead is create instance attributes in __init__, e.g.:

class Field_node(object):
    def __init__(self):
        self.field_phenotype_id = -1
        self.field_name = ''
        self.field_parent_id = -1
        self.child_nodes = []