在python中打印非类型对象的方法返回的最后一个列表

我有一个递归算法，需要能够返回列表列表

如果我打印剩余的列表，我会得到许多不同的列表，直到我们得到最后一个。那么我就不能返回最后一个列表了

这是我的密码：

def subset_sum(numbers, target, partial=[], result = []):
    s = sum(partial)

    # check if the partial sum is equals to target
    if s == target:
        result.append(partial)
    if s >= target and len(numbers) == 1:
        print(result)
        print(type(result))
        return result

    for i in range(len(numbers)):
        n = numbers[i]
        remaining = numbers[i+1:]
        subset_sum(remaining, target, partial + [n], result)


if __name__ == "__main__":
    print(subset_sum([3,9,8,4,5,7,10],15))

以下是输出：

[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]                                                                      
<class 'list'>                                                          
[]            

[]
[]                                                                      
[]                                                                      
[]                                                                      
[]                                                                      
[]                                                                      
[]                                                                      
[]            

（等）

[[3, 8, 4], [3, 5, 7], [8, 7]]
[[3, 8, 4], [3, 5, 7], [8, 7]]
没有一个

正如您所看到的，它确实执行了我希望它执行的操作，即使它在最后生成了一个列表，也无法返回

---

无论如何。提前感谢您的帮助。感谢所有帮助：）

A

return

语句只将其值返回调用范围。嵌套函数调用时，如果所有中间函数

也返回
，则叶函数只能向根函数返回一个值：

>>> def do_return(call, *args):
...     return call(*args)

>>> def donot_return(call, *args):
...     call(*args)
...
>>> do_return(do_return, do_return, do_return, lambda: 5)
5
>>> do_return(do_return, donot_return, do_return, lambda: 5)
None

在递归函数中，这意味着每个递归路径都必须返回


在您的情况下，在到达
for
循环时，不会再次返回任何内容。这意味着所有嵌套递归调用都不能向调用的根返回值。一种简单的方法是检查递归调用是否返回有意义的值：

    ...
    found = subset_sum(remaining, target, partial + [n], result)
    if found is not None:
        return found

或者，使用异常

但是，您的方法并没有一致地递归-您在每个步骤上修改相同的
result=[]
列表。要么使用不修改输入但返回结果的纯函数，要么直接修改并返回结果

    ...
    subset_sum(remaining, target, partial + [n], result)
return result

有效的递归方法如下所示：

def subset_sum(numbers: list, target: int, split=0) -> list:
    """
    :param numbers: set of numbers to search for subsets
    :param target: the desired subset sum to search for
    :param split: index at which to split subsequences
    """
    total = sum(numbers)
    if total == target:
        return [numbers]
    elif total < target:
        return []
    else:
        results = []
        for i in range(split, len(numbers)):
            remaining = numbers[:i] + numbers[i+1:]
            results.extend(subset_sum(remaining, target, i))
        return results


if __name__ == "__main__":
    print(subset_sum([3, 9, 8, 4, 5, 7, 10], 15))
# [[5, 10], [8, 7], [3, 5, 7], [3, 8, 4]]

def subset_sum（数字：list，目标：int，split=0）->list:
"""
：param numbers：用于搜索子集的数字集
：param target：要搜索的所需子集和
：param split：分割子序列的索引
"""
总数=总和（个数）
如果总计==目标：
返回[数字]
elif总计<目标：
返回[]
其他：
结果=[]
对于范围内的i（拆分，len（数字））：
剩余=数字[：i]+数字[i+1:]
结果.扩展（子集_和（剩余，目标，i））
返回结果
如果名称=“\uuuuu main\uuuuuuuu”：
打印（子集和（[3,9,8,4,5,7,10,15））
# [[5, 10], [8, 7], [3, 5, 7], [3, 8, 4]]

值得注意的是，每个路径都返回一个有效的结果（即使它是空的）。这意味着不会删除任何结果。此外，返回值是将信息移动到调用者的唯一方法-不会修改共享数据。
在for循环之后不会返回任何值。如果代码进入for循环，则不会返回任何值。也许函数的最后一行应该是
返回子集_sum（…）
？不是真的。其思想是遍历递归树，只在某些条件下返回。因此，除非它返回它所返回的值，否则它实际上不需要返回。如果您使其进入for循环并再次调用该函数，并且该调用返回了一些值，那么您将丢失该返回值。可能会重复
def subset_sum(numbers: list, target: int, split=0) -> list:
    """
    :param numbers: set of numbers to search for subsets
    :param target: the desired subset sum to search for
    :param split: index at which to split subsequences
    """
    total = sum(numbers)
    if total == target:
        return [numbers]
    elif total < target:
        return []
    else:
        results = []
        for i in range(split, len(numbers)):
            remaining = numbers[:i] + numbers[i+1:]
            results.extend(subset_sum(remaining, target, i))
        return results


if __name__ == "__main__":
    print(subset_sum([3, 9, 8, 4, 5, 7, 10], 15))
# [[5, 10], [8, 7], [3, 5, 7], [3, 8, 4]]