Python 3.x &引用；“深度复制”；Python中的问题

我正在为TJ Wriggler问题编写一个人工智能解决方案，我遇到了一个导致我的程序挂起的问题。我不太确定它是什么，因为我应该有足够的内存来运行代码。更确切地说，我想我正在改变一个我不应该去的地方，但我似乎无法确定确切的位置

我将运行整个执行过程，直到程序挂起：

首先，搜索功能：

def BFTS(the_frontier):
    index = 0
    frontier = [the_frontier]
    while(True):
        if (not frontier):
            return None
        leaf = frontier.pop(0)
        if (leaf.GoalTest()):
            return leaf
        index = index + 1
        moves_list = leaf.FindMoves(index)
        while(len(moves_list) > 0):
            frontier.append(moves_list.pop(0))

def FindMoves(self, current_index):
    moves_list = []
    for wriggler in self.State.Wrigglers:
        for seg in [wriggler.Head(), wriggler.Tail()]:
            is_head = {
                wriggler.Head() : True,
                wriggler.Tail() : False}[seg]
            for move in self.State.FindEmptySpaces(seg):
                if (move is not None):
                    moves_list.append(self.Move(wriggler.Index, 
                        is_head, move['x'], move['y'], current_index))
    return moves_list

def Move(self, wriggler_id, is_head, new_x, new_y, current_index):
    head_or_tail = {True : 0, False : 1}[is_head]

    # Find action
    new_action = ("%s %s %s %s" % (wriggler_id, head_or_tail, new_x, new_y))

    new_node = self.CopyNode()
    new_index = current_index

    new_node.State.MoveWriggler(wriggler_id, new_y, new_x, is_head)
    return Node(new_node.State, new_action, new_index, self.Cost + Node.Step_Cost)

def CopyNode(self):
    # Create new Spaces List-of-List
    new_spaces = DataStructures.CopyListOfLists(self.State.Spaces)
    new_state = Board(new_spaces)

    # Create new List of Actions
    new_action = []
    for action in self.Action:
        new_action.append(action)

    # Create new Node
    return Node(new_state, new_action, self.Parent, self.Cost)

def CopyListOfLists(the_list_of_list):
    new_list = []
    for lists in the_list_of_list:
        temp_list = []
        for items in lists:
            temp_list.append(items)
        new_list.append(temp_list)
    return new_list

这将调用FindMoves（）函数：

def BFTS(the_frontier):
    index = 0
    frontier = [the_frontier]
    while(True):
        if (not frontier):
            return None
        leaf = frontier.pop(0)
        if (leaf.GoalTest()):
            return leaf
        index = index + 1
        moves_list = leaf.FindMoves(index)
        while(len(moves_list) > 0):
            frontier.append(moves_list.pop(0))

def FindMoves(self, current_index):
    moves_list = []
    for wriggler in self.State.Wrigglers:
        for seg in [wriggler.Head(), wriggler.Tail()]:
            is_head = {
                wriggler.Head() : True,
                wriggler.Tail() : False}[seg]
            for move in self.State.FindEmptySpaces(seg):
                if (move is not None):
                    moves_list.append(self.Move(wriggler.Index, 
                        is_head, move['x'], move['y'], current_index))
    return moves_list

def Move(self, wriggler_id, is_head, new_x, new_y, current_index):
    head_or_tail = {True : 0, False : 1}[is_head]

    # Find action
    new_action = ("%s %s %s %s" % (wriggler_id, head_or_tail, new_x, new_y))

    new_node = self.CopyNode()
    new_index = current_index

    new_node.State.MoveWriggler(wriggler_id, new_y, new_x, is_head)
    return Node(new_node.State, new_action, new_index, self.Cost + Node.Step_Cost)

def CopyNode(self):
    # Create new Spaces List-of-List
    new_spaces = DataStructures.CopyListOfLists(self.State.Spaces)
    new_state = Board(new_spaces)

    # Create new List of Actions
    new_action = []
    for action in self.Action:
        new_action.append(action)

    # Create new Node
    return Node(new_state, new_action, self.Parent, self.Cost)

def CopyListOfLists(the_list_of_list):
    new_list = []
    for lists in the_list_of_list:
        temp_list = []
        for items in lists:
            temp_list.append(items)
        new_list.append(temp_list)
    return new_list

findEmptySpace（）查找所有可以移入的空间，并返回表示笛卡尔坐标的字典列表。然后，FindMoves（）函数调用Move（）函数：

def BFTS(the_frontier):
    index = 0
    frontier = [the_frontier]
    while(True):
        if (not frontier):
            return None
        leaf = frontier.pop(0)
        if (leaf.GoalTest()):
            return leaf
        index = index + 1
        moves_list = leaf.FindMoves(index)
        while(len(moves_list) > 0):
            frontier.append(moves_list.pop(0))

def FindMoves(self, current_index):
    moves_list = []
    for wriggler in self.State.Wrigglers:
        for seg in [wriggler.Head(), wriggler.Tail()]:
            is_head = {
                wriggler.Head() : True,
                wriggler.Tail() : False}[seg]
            for move in self.State.FindEmptySpaces(seg):
                if (move is not None):
                    moves_list.append(self.Move(wriggler.Index, 
                        is_head, move['x'], move['y'], current_index))
    return moves_list

def Move(self, wriggler_id, is_head, new_x, new_y, current_index):
    head_or_tail = {True : 0, False : 1}[is_head]

    # Find action
    new_action = ("%s %s %s %s" % (wriggler_id, head_or_tail, new_x, new_y))

    new_node = self.CopyNode()
    new_index = current_index

    new_node.State.MoveWriggler(wriggler_id, new_y, new_x, is_head)
    return Node(new_node.State, new_action, new_index, self.Cost + Node.Step_Cost)

def CopyNode(self):
    # Create new Spaces List-of-List
    new_spaces = DataStructures.CopyListOfLists(self.State.Spaces)
    new_state = Board(new_spaces)

    # Create new List of Actions
    new_action = []
    for action in self.Action:
        new_action.append(action)

    # Create new Node
    return Node(new_state, new_action, self.Parent, self.Cost)

def CopyListOfLists(the_list_of_list):
    new_list = []
    for lists in the_list_of_list:
        temp_list = []
        for items in lists:
            temp_list.append(items)
        new_list.append(temp_list)
    return new_list

此函数调用CopyNode（）函数：

def BFTS(the_frontier):
    index = 0
    frontier = [the_frontier]
    while(True):
        if (not frontier):
            return None
        leaf = frontier.pop(0)
        if (leaf.GoalTest()):
            return leaf
        index = index + 1
        moves_list = leaf.FindMoves(index)
        while(len(moves_list) > 0):
            frontier.append(moves_list.pop(0))

def FindMoves(self, current_index):
    moves_list = []
    for wriggler in self.State.Wrigglers:
        for seg in [wriggler.Head(), wriggler.Tail()]:
            is_head = {
                wriggler.Head() : True,
                wriggler.Tail() : False}[seg]
            for move in self.State.FindEmptySpaces(seg):
                if (move is not None):
                    moves_list.append(self.Move(wriggler.Index, 
                        is_head, move['x'], move['y'], current_index))
    return moves_list

def Move(self, wriggler_id, is_head, new_x, new_y, current_index):
    head_or_tail = {True : 0, False : 1}[is_head]

    # Find action
    new_action = ("%s %s %s %s" % (wriggler_id, head_or_tail, new_x, new_y))

    new_node = self.CopyNode()
    new_index = current_index

    new_node.State.MoveWriggler(wriggler_id, new_y, new_x, is_head)
    return Node(new_node.State, new_action, new_index, self.Cost + Node.Step_Cost)

def CopyNode(self):
    # Create new Spaces List-of-List
    new_spaces = DataStructures.CopyListOfLists(self.State.Spaces)
    new_state = Board(new_spaces)

    # Create new List of Actions
    new_action = []
    for action in self.Action:
        new_action.append(action)

    # Create new Node
    return Node(new_state, new_action, self.Parent, self.Cost)

def CopyListOfLists(the_list_of_list):
    new_list = []
    for lists in the_list_of_list:
        temp_list = []
        for items in lists:
            temp_list.append(items)
        new_list.append(temp_list)
    return new_list

CopyNode（）函数调用CopyListofList（）函数：

def BFTS(the_frontier):
    index = 0
    frontier = [the_frontier]
    while(True):
        if (not frontier):
            return None
        leaf = frontier.pop(0)
        if (leaf.GoalTest()):
            return leaf
        index = index + 1
        moves_list = leaf.FindMoves(index)
        while(len(moves_list) > 0):
            frontier.append(moves_list.pop(0))

def FindMoves(self, current_index):
    moves_list = []
    for wriggler in self.State.Wrigglers:
        for seg in [wriggler.Head(), wriggler.Tail()]:
            is_head = {
                wriggler.Head() : True,
                wriggler.Tail() : False}[seg]
            for move in self.State.FindEmptySpaces(seg):
                if (move is not None):
                    moves_list.append(self.Move(wriggler.Index, 
                        is_head, move['x'], move['y'], current_index))
    return moves_list

def Move(self, wriggler_id, is_head, new_x, new_y, current_index):
    head_or_tail = {True : 0, False : 1}[is_head]

    # Find action
    new_action = ("%s %s %s %s" % (wriggler_id, head_or_tail, new_x, new_y))

    new_node = self.CopyNode()
    new_index = current_index

    new_node.State.MoveWriggler(wriggler_id, new_y, new_x, is_head)
    return Node(new_node.State, new_action, new_index, self.Cost + Node.Step_Cost)

def CopyNode(self):
    # Create new Spaces List-of-List
    new_spaces = DataStructures.CopyListOfLists(self.State.Spaces)
    new_state = Board(new_spaces)

    # Create new List of Actions
    new_action = []
    for action in self.Action:
        new_action.append(action)

    # Create new Node
    return Node(new_state, new_action, self.Parent, self.Cost)

def CopyListOfLists(the_list_of_list):
    new_list = []
    for lists in the_list_of_list:
        temp_list = []
        for items in lists:
            temp_list.append(items)
        new_list.append(temp_list)
    return new_list

据我所知，该程序挂起在函数CopyNode（）中，但奇怪的是，它只在第二次遍历Search_BFTS（）时执行此操作。正如我所说，我可能在某个地方更改了一个引用，但我对Python的经验不足，无法确定这是否是实际问题

能提供的任何帮助都将是巨大的

---

谢谢，

您不会碰巧创建了类属性而不是实例属性，是吗？在类级别定义的任何变量都是类属性；实例属性应该在

\uu init\uuu

中创建

frontier

永远不会等于

None

。这是一张单子。列表不是

None

；清单就是清单。如果要检查它是否为空，可以使用

If not frontier

return moves\u listmoves\u list=[]

——这不是有效的Python语法。看起来你不小心把两行混在了一起。不，我有一些类属性，但只有那些应该应用于所创建类的所有对象。否则，属性将在initIs

SearchBFTS

中创建，以修改作为

the_frontier

传入的对象？看起来你可能打算复制一份。