为什么使用 any() 会导致最大递归深度

Question

长话短说，我写了一个递归函数来解决一个问题。问题本身无所谓，但我会简单介绍一下：

找出是否可以在字符串矩阵中找到一个单词。 递归需要在一个字母上找到匹配项，然后搜索邻居（上、下、左、右）以找到下一个字母。如果它最终导致找到所有字母的路径，则找到该单词。

递归函数为finder

def finder(self, board: List[List[str]], word: str, idx: int, coor: Tuple[int, int], prev: Dict[Tuple[int], int]):
    N = len(word)
    x, y = coor[0], coor[1]
    row, col = len(board), len(board[0])
    if idx == N: 
        return True
    elif not 0 <= x < row or not 0 <= y < col:  
        return False
    elif coor in prev:
        return False
    elif board[x][y] != word[idx]:
        return False
    else:
        new_prev = prev.copy()
        new_prev[coor] = 1 

        up = (x - 1, y)
        down = (x + 1, y)
        left = (x, y - 1)
        right = (x, y + 1)

        # Old
        # return any([self.finder(board, word, idx + 1, new_coor, new_prev) for new_coor in [up, down, left, right]])

        # New
        return self.finder(board, word, idx + 1, up, new_prev) or \
               self.finder(board, word, idx + 1, down, new_prev) or \
               self.finder(board, word, idx + 1, left, new_prev) or \
               self.finder(board, word, idx + 1, right, new_prev)

在代码中，我首先尝试了一个单行：

return any([finder(board, word, idx + 1, new_coor, prev) for new_coor in [up, down, left, right]])

当矩阵很大并且单词很长时，它花费了我最大的递归。但是我找不到更好的算法，直到我看到答案，这与我的几乎相同，但只有最后一部分使用：

return finder(board, word, idx + 1, up, prev) or \
       finder(board, word, idx + 1, down, prev) or \
       finder(board, word, idx + 1, left, prev) or 
       finder(board, word, idx + 1, right, prev)

这样就解决了问题。

现在我很困惑，我认为这两个 return 具有相同的含义，除了使用 any 允许单行，这更优雅......那么这里有什么区别？

谢谢！

Answer 1

您正在创建一个详尽的列表，然后将其传递给any()。观察：

>>> def thing(x):
...   print(x)
...   return True
...
>>> any(thing(y) for y in (1, 2, 3, 4))
1
True
>>> any([thing(y) for y in (1, 2, 3, 4)])
1
2
3
4
True

请注意，在后一种情况下，您如何使用列表解析来填充完整列表，然后才将其传递给 any 进行评估。