Python—递归创建列表的最佳方法？

在这段代码中，我动态地将列表附加到列表（ans）中。在这个例子中，我使用递归和元组来构建每个子列表，因为它是不可变的。然后，我将其转换为一个列表，并将其附加到我的答案中。如果我只使用列表，我将无法在每次调用函数时传递副本

以这种方式使用元组是否有性能方面的缺点？是否有更好的方法递归创建类似问题的列表

---

而且，这种方法在二维列表中也不起作用。。。制作2D不可变列表的最佳方法是什么？

我猜

sum

是您希望执行的最大遍历次数

以下内容将实现此目的：

# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None      

sum = 25
  ans = []
  def recurse(s, traverse, ls):
                #append tuple
                ls = ls + (traverse.val,)
                if (traverse.right):
                    recurse(s, traverse.right, ls)
                if (traverse.left):
                    recurse(s, traverse.left, ls)
                if (s==sum): 
                    #convert touple and add to answer
                    tmp = list(ls)
                    ans.append(tmp)

  a = tuple()
  recurse(0, root, a)

那么，你可以这样称呼它：

def traverse(root, limit=None, count=0):
    if not root or count == limit:
        return []
    traversal = [root.val]
    traversal += traverse(root.right, limit, count + len(traversal))
    traversal += traverse(root.left, limit, count + len(traversal))
    return traversal

---

或者，如果您可以在

\uuuu init\uuuuu

处提供

右

和

左

节点，您可以采用一种很酷的功能风格方法：

root = TreeNode(20)
root.right = TreeNode(40)
root.right.right = TreeNode(50)
root.right.left = TreeNode(30)
root.left = TreeNode(10)
root.left.left = TreeNode(5)

traverse(root)          // [20, 40, 50, 30, 10, 5]
traverse(root, limit=1) // [20]
traverse(root, limit=4) // [20, 40, 50, 30]

---

如果traverse.right不是None:而不是

if（traverse.right）：

这有什么原因吗？如果调用

if object

，其中

object

是类的某个实例，它将调用其

bool

或

nonzero

方法（取决于python版本）。因此，如果

if var

正在检查某些对象的返回值

\uuuubool\uuuuu

/

\uuuuuu非零\uuuuu

的if

var

方法为None，这是不明确的

if object为None

，但只会显式检查变量的标识是否为

None

。

print(
    traverse(
        Node(20,
            right=Node(40,
                right=Node(50),
                left=Node(30)),
            left=Node(10,
                left=Node(5))),
        limit=3))
 # > [20, 40, 50]