我的python树怎么了

Question

I'm trying to implement a tree structure, but when I'm trying to print data out in my tree, unexpected results are shown.

Correct result will be :

root
 - A1
-- A2
--- A3
---- A4
----- A5

But I got :

root
 - A1
-- A1
--- A2
~ infinite loop

What's wrong with my code? Can you answer me?

#!/usr/bin/python
class TreeNode :
    def __init__(self,key,obj=dict()) :
        print 'Node with '+key+' is created'
        self.key=key
        self.child=obj
    def add_child(self, key, obj) :
        self.child[key]=obj
        print 'child len ',
        print len(self.child)
    def get_child(self) :
        for key in self.child.keys() : 
            print key,
            pass
        print ''
        return self.child
    def find_child(self,key) :
        return self.child[key]
    def is_leap(self) : 
        print 'is_leap ',
        print len(self.child)
        if len(self.child)==0 :
            return 1
        else : return 0
    def append_rec(self,hier,data,depth) :
        # hier & data are lists
        if len(hier)== 1 : 
            print 'end of hierachy. append complete @ depth ',
            print depth
            return

        tmp = hier[0]
        tmp_child = hier[1:]
        name = str(hier[0])
        print 'self ',
        print tmp,
        print 'childs ',
        print tmp_child
        child_list = self.get_child()
        if child_list != None :
            if not name in child_list.keys() :  
                lc = TreeNode(name)
                self.add_child(name,lc)
                return lc.append_rec(hier[1:],data,depth+1)
            else :
                lc =child_list[name]
                return lc.append_rec(hier[1:],data,depth+1)
    def print_all(self,depth) :
        for i in range(depth) : print '-', 
        print self.key
        if len(self.child) == 0 : return
        if depth > 10 : 
            print 'depth limit over'
            return
        else :
            for k in self.child.keys() : 
                print 'Looking child having key = '+k
                return (self.child[k]).print_all(depth+1)




    # recursive method
class Tree :
    index = 0
    # root node of tree
    def __init__(self) :
        self.root=TreeNode('root')
        self.index=0
    def get_child(self) :
        return self.root.get_child()  
    def print_all(self) :
        self.root.print_all(0)
    def traverse(self) :
        node=self.root
        depth=0

        childs = node.get_child()
        if node.is_leap() : return
        else :
            for c in childs.keys() :
                print c,
                return self.traverse_rec(childs[c],depth+1)
        print ' end'

    def traverse_rec(self,node,depth) :
        i=0
        print 'depth ',
        print i,
        childs = node.get_child()
        if node.is_leap() : return
        else :
            for c in childs.keys() :
                print c,
                return self.traverse_rec(childs[c],depth+1)
        print ' end'


    def append(self,tup) :
        # root
        tmp = tup[0].split('/')
        data = tup[1]
        print 'root ['+data+']',
        tmp_child = tmp[1:]
        name = str(tmp[0])
        # if treenode with name tmp[0]
        child_list = self.root.get_child()
        if child_list != None :
            if not name in child_list.keys() :  
                #print 'name = '+name
                lc = TreeNode(name)
                self.root.add_child(name,lc)
                lc.append_rec(tmp_child,data,1)
            else :
                lc=child_list[name]
                lc.append_rec(tmp_child,data,1)


tree = Tree()
test_string = ('A1/A2/A3/A4/A5','example1')
tree.append(test_string)
tree.print_all()

Answer 1

In Python, default arguments are only evaluated once. So each time you create a TreeNode without an explicit obj argument, it gets assigned to the same dict.

One way to get around this is to use None as a default argument instead, like so.

def __init__(self,key,obj=None) :
    print 'Node with '+key+' is created'
    self.key=key
    self.child=obj if obj is not None else {}

Another option is to do a defensive copy. This will help in cases where you accidentally pass it a dict by reference when you don't want to, though this means that it may mask other bugs. Also note that this will only do a shallow copy, which is usually what you want, but not always.

def __init__(self,key,obj=dict()) :
    print 'Node with '+key+' is created'
    self.key=key
    self.child=obj.copy()