Python保留旧的对象信息

Question

我正在使用一类具有[1,1,2]形式的“单词”的节点制作一类有根树，其中[1,1]是[1,1,2]的父节点]和[1,1,1]是[1,1,2]的前一个兄弟，一个孩子的名单和一个父母。出于某种原因，在for循环部分中，第二次将nextChild = Node(word)行作为输入作为一个孩子（前一个nextChild），即使我没有传递任何东西作为孩子。我不知道为什么会这样。如果需要，我会发布更多代码。

编辑：这是整个Tree.py文件

import pdb

class Word:
    def __init__(self, intList = []):
        self.intList = intList

    def __len__(self):
        return len(self.intList)

    def __getitem__(self, i):
        if i < len(self):
            return self.intList[i]
        else:
            raise AttributeError

    def __str__(self):
        if len(self.intList) == 0:
            return "<e>"

        selfStr = "<"

        for i, val in enumerate(self.intList):
            selfStr = selfStr + str(val)
            selfStr = selfStr + ("" if i == (len(self.intList) - 1)  else ", ")

        selfStr = selfStr + ">"

        return selfStr

    def compare(self, word2):
        shortestLength = len(self) if len(self) < len(word2) else len(word2)

        for i in xrange(shortestLength):
            if self[i] < word2[i]:
                return -1
            elif self[i] > word2[i]:
                return 1

        return -1 if len(self) < len(word2) else 1 if len(self) > len(word2) else 0

    def isPrefixOf(self, word2):
        if len(self) == 0 and len(word2) == 1:
            return True
        if len(self) != len(word2) + 1:
            return False

        for i in xrange(len(self)):
            if self[i] != word2[i]:
                return False

        return True

class Node:
    def __init__(self, word = Word(), children = [], parent = -1):
        self.label = word
        self.children = children
        self.parent = parent
        self.currentChild = 0

        for i, child in enumerate(self.children):
            if (not self.label.isPrefixOf(child.label)):
                raise ValueError("The node " + str(child.label) + " is not a valid child of " + str(self.label))

    def __str__(self):
        return str(self.label)

    def addChild(self, child):
        #check if these are valid brothers
        if len(self.children) == 0 and child.label[len(child.label) - 1] != 1:
            raise ValueError("The node " + str(child.label) + " is not a valid child of " + str(self.label))

        elif len(self.children) != 0 and not self.children[len(self.children) - 1].isPerviousBrotherOf(child):
            raise ValueError("The node " + str(child.label) + " is not a valid child of " + str(self.label))

        #check if valid parent
        if not self.label.isPrefixOf(child.label):
            raise ValueError("The node " + str(child.label) + " is not a valid child of " + str(self.label))

        self.children.append(child)

    def isValidParentOf(self, node):
        return self.label.isPrefixOf(node.label)

    def isPerviousBrotherOf(self, word2):
        if len(self) != len(word2):
            return False

        return self[len(self) - 1] == word2[len(word2) - 1] - 1

    def getParent(self):
        return self.parent

    def setParent(self, parent):
        self.parent = parent

    def getNextChild(self):
        if self.currentChild >= len(self.children):
            return -1
        else:
            self.currentChild = self.currentChild + 1
            return self.children[self.currentChild - 1]

    def resetPosition(self):
        self.currentChild = 0

    def numChildren(self):
        return len(self.children)

class Tree:
    def __init__(self, intList):
        if len(intList) == 0:
            raise ValueError("Trees cannot have size zero.")

        wordList = map(lambda x: Word(x), intList)
        wordList = sort(wordList)

        self.root = Node(wordList[0])
        currentNode = self.root

        for i in xrange(1, len(wordList)):
            word = wordList[i]
            nextChild = Node(word)

            while (currentNode != -1 and not currentNode.isValidParentOf(nextChild)):
                currentNode.resetPosition()
                currentNode = currentNode.getParent()

            if (currentNode == -1):
                raise ValueError("The list of words " + map(str, wordList) + " is not a valid tree.")

            currentNode.addChild(nextChild)
            nextChild.setParent(currentNode)
            currentNode = currentNode.getNextChild()

        while (currentNode.getParent() != -1):
            currentNode.resetPosition()
            currentNode = currentNode.getParent()

        currentNode.resetPosition()
        self.root = currentNode
        self.size = len(wordList)
        self.current = self.root

    def __str__(self):
        outStr = ""

        outStr = createString(self.root)

    def createString(self, node):
        outStr = "(" + str(node)

        child = node.getNextChild()

        while child != -1:
            outStr += " " + createString(child) + ")"

        return outStr + ")"

def sort(inList):
    if len(inList) <= 1:
        return inList
    return merge(sort(inList[:len(inList)/2]), sort(inList[len(inList)/2:]))

def merge(list1, list2):
    outlist = []
    i = 0
    j = 0

    while (i < len(list1) or j < len(list2)):
        if i >= len(list1):
            while (j < len(list2)):
                outlist.append(list2[j])
                j = j + 1
        elif j >= len(list2):
            while (i < len(list1)):
                outlist.append(list1[i])    
                i = i + 1
        elif list1[i].compare(list2[j]) == -1:
            outlist.append(list1[i])
            i = i + 1
        else:
            outlist.append(list2[j])
            j = j + 1

    return outlist

以下是一些测试代码     来自树导入树

t = Tree([[], [1], [2], [3], [1, 1], [1, 2], [2, 1], [3, 1], [3, 2], [3, 3]])
print str(t)