Python的两个递归调用argumen的共享实例

Question

我试图通过一个2D矩阵的所有可能的路径（条件是我只能向下或向右）。 以下是我正在尝试的：

rows = 3
columns = 3
# Class definition for node of the tree
class Node(object):
    def __init__(self):
        self.location = None
#  Starting the tree
tree = Node()
tree.location = [0,0]
def generateRestOfThePath(node):
    print 'Receiving node'
    print node.location
    if (node.location[0] >= rows) or (node.location[1] >= columns):
        print 'Out of playground', node.location
    elif node.location == [rows-1, columns -1]:
        print 'End of a path'
    elif  node.location[0] == rows-1:
        node.location[1] += 1
        print 'Reached bottom can only go right', node.location
        generateRestOfThePath(node)
    elif node.location[1] == columns -1:
        node.location[0] += 1
        print 'Reached right can only go down', node.location
        generateRestOfThePath(node)
    else:
        print 'Neither reached down nor right'  
        node.location[0] += 1
        print 'Going down', node.location
        generateRestOfThePath(node)
        print 'Finished with down', node.location
        node.location[1] +=1
        print 'Going Right', node.location  
        generateRestOfThePath(node)    
generateRestOfThePath(tree)

我得到的结果是：

Receiving node
[0, 0]
Neither reached down nor right
Going down [1, 0]
Receiving node
[1, 0]
Neither reached down nor right
Going down [2, 0]
Receiving node
[2, 0]
Reached bottom can only go right [2, 1]
Receiving node
[2, 1]
Reached bottom can only go right [2, 2]
Receiving node
[2, 2]
End of a path
Finished with down [2, 2]
Going Right [2, 3]
Receiving node
[2, 3]
Out of playground [2, 3]
Finished with down [2, 3]
Going Right [2, 4]
Receiving node
[2, 4]
Out of playground [2, 4]

我的问题是：

Finished with down [2, 2]

这不是[1, 0]吗？你知道吗

我在想：

0,0
 | \ else case
 | 1,0 First recursion call
 | | \else case
 | | 2,0 First recursion call
 | | | only go right case
 | | 2,1 First and only recursive call
 | | | only go right case
 | | 2,2 First and only recursive call
 | | | End of path, No Recursion here
 | | / Since there is no recursion, the second recursion should be called (this is what I am thinking)
 | 1,0 Second recursion call
 | .........
 | .........
 |/

但这并没有发生。有人请给我指出正确的方向。你知道吗

更新：

我认为，不像C或C++ Python，它不把值1,0保存在内存中，实际上只为一个节点实例使用一个内存位置。我认为它们是不同的实例，但根据python，它们都是相同的实例。所以我认为真正的问题是。如何拥有不同的节点实例而不是一个共享的节点实例？你知道吗

Answer 1

我相信你的问题是，当你认为你是正确的，你实际上是正确的和下降，因为规则

node.location[0] += 1

在这种情况下也会执行

node.location[1] += 1

编辑：对不起，快读吧，误解了你的问题：）

行print "finished with with down ..."仅在递归函数调用完成后执行。此函数调用仅在来自特定节点的所有路径完成后完成。因此，当脚本打印出第finished with down [1,0]行时，它已经完成了从[1,0]可以访问的所有节点。因为您不能从[2,2]向右或向下移动，所以这个节点总是首先完成，然后首先打印出finished with [2,2]行。你知道吗

Answer 2

好吧，因为问题只是一个共享实例，而不是一个以上的实例，所以我拍了一张照片并用胶带记录了情况。我认为这不是一个理想的解决办法。我真的很想有人骂我，让我走上正确的道路。你知道吗

以下是我所做的：

"The key point here will be that we won't be storing any variables, we will only be passing values"

rows = 3
columns = 3

def generateRestOfThePath(node):
    rowNumber, columnNumber = node
    print 'Receiving node', rowNumber, columnNumber
    if (rowNumber >= rows) or (columnNumber >= columns):
        print 'Out of playground', rowNumber, columnNumber
    elif [rowNumber, columnNumber] == [rows-1, columns -1]:
        print 'End of a path'
    elif rowNumber == rows-1:
        columnNumber += 1
        print 'Reached bottom can only go right', rowNumber, columnNumber
        generateRestOfThePath([rowNumber, columnNumber])
    elif columnNumber == columns -1:
        rowNumber += 1
        print 'Reached right can only go down', rowNumber, columnNumber
        generateRestOfThePath([rowNumber, columnNumber])
    else:
        print 'Neither reached down nor right'  
        rowNumber += 1
        print 'Going down', rowNumber, columnNumber
        generateRestOfThePath([rowNumber, columnNumber])
        print 'Finished with down', rowNumber, columnNumber
        rowNumber -= 1
        columnNumber +=1
        print 'Going Right', rowNumber, columnNumber    
        generateRestOfThePath([rowNumber, columnNumber])
        print 'Finished with right'

generateRestOfThePath([0, 0])

Answer 3

此时，您只在整个程序中创建了一个节点，正如我在评论中所说的。如果要为矩阵中经过的每个单元格创建一个新节点，应该在对generateRestOfThePath()的调用中执行。对于下一个节点的每个可能值，生成该节点，然后用该下一个节点调用generateRestOfThePath。如果要在完整路径跟踪完成时打印起始值，则不能在递归函数中执行。（这将在每次完成跟踪每个中间节点的可能延续时打印语句。）

请允许我给你一点建议。你不需要一个Node类。你可以只使用一个元组或一个列表。尽量使用python中的内置结构。这会让你的生活更轻松。你知道吗

我不想为你写代码，因为那样对你的学习没有帮助。如果你跑得更困难，试试看，喊我一声。祝你好运。你知道吗