Python 超过最大递归深度：如何解决此问题

所以我在做一个数独解算器。递归解算器函数的代码粘贴在下面。如果你想让我解释我的代码的任何部分，请告诉我，我只是让它工作，所以它不是最健壮的

attempts变量基本上跟踪在每个正方形上进行了多少次尝试，并且基本上有助于定义在每次迭代中使用哪些子树和叶节点

对于我的问题：我一直得到递归错误：最大递归深度超过了，并且正在寻找一些关于如何解决这个问题的建议？如果我要围绕while循环重新构造代码，是否有一种方法可以简化代码，是否有一种方法可以安全地覆盖此错误，请告诉我

def solve(board, count=0, tree=0):
    global attempts
    global originalBoard

    # breaks recursive loop when reached the end of the board
    if count >= 80:
        print(board)
        return board

    # sets up global variables for beginning of solution
    elif count == 0:
        attempts = np.zeros((9, 9), int)
        originalBoard = board.copy()

    # converts count into x and y, allows iteration from left to right (rows)
    x = count % 9
    y = count // 9

    # skips iteration if theres already an original value there
    if board[x, y] != 0 and board[x, y] == originalBoard[x, y]:
        return solve(board, count + 1)

    # collects all possible solutions
    solutions = possibleSolutions(board, count)
    numOfSolutions = len(solutions)
    validSolutions = solutions[tree:]
    numOfValidSolutions = len(validSolutions)

    # if we've reached the end of a specific subtree, we reset, go back one, and reset the tree
    if tree > numOfSolutions:
        board[count % 9, count // 9] = originalBoard[count % 9, count // 9]     # reset value
        count -= 1                                                              # go back one
        tree = attempts[count % 9, count // 9]                                  # picks up where left off
        return solve(board, count, tree)


    attempts[count % 9, count // 9] = tree

    if numOfValidSolutions >= 1:
        board[x, y] = validSolutions[0]
        return solve(board, count + 1)
    
    elif numOfValidSolutions == 0:
        count -= 1                                                              # go back
        attempts[count % 9, count // 9] += 1
        tree = attempts[count % 9, count // 9]                                  # move on to next leaf node
        board[count % 9, count // 9] = originalBoard[count % 9, count // 9]     # reset failed value
        return solve(board, count, tree)  

---

您的代码正在使用尾部递归-每个分支将只调用一次

solve

方法。这意味着在没有递归的情况下将其重写到循环中应该不会那么困难

但是，如果您只想提高递归深度的限制，可以使用代码：

import sys 

sys.setrecursionlimit(10**6) 

默认限制为

10**4