Question

我有一个函数，它的名字是positive_negative

def positive_negative(list_changes):
    """ (list of number) -> (number, number) tuple

    list_changes contains a list of float numbers. Return a 2-item
    tuple where the first item is the sum of the positive numbers in list_changes and
    the second is the sum of the negative numbers in list_changes.

    >>> positive_negative([0.01, 0.03, -0.02, -0.14, 0, 0, 0.10, -0.01])
    (0.14, -0.17)
    """

我可以使用列表技术编写此函数，如下所示：

def positive_negative(list_changes):
    pos = sum([item for item in list_changes if item > 0.0])
    neg = sum ([item for item in list_changes if item < 0.0]) 
    return pos, neg

这是一个很好的解决方案。现在我的问题是如何使用递归技术来解决相同的功能，我已经尝试了以下代码，但不幸的是有一些错误。

def positive_negative(list_changes):
    pos = 0.0
    neg = 0.0
    if len(list_changes)== 0:
        pos =+ 0.0
        neg =+ 0.0
        return pos,neg
    else:
        if list_changes[0] > 0.0 :
            pos =+ list_changes[0]
        else:
            neg =+ list_changes[0]
        positive_negative(list_changes[1:])


    return pos,neg

你能帮我找出我的错误以及如何获得正确的递归功能。

谢谢

Answer 1

你的第一个问题是：

pos =+ list_changes[0]

Python没有=+运算符。所以，这相当于：

pos = (+list_changes[0])

由于list_changes[0]是一个数字，+n与任何数字的n相同（除非在某些无关紧要的边缘情况下），您只需更换每次pos而不是添加。

你可能想要这个：

pos += list_changes[0]

但是你试图使用+=的事实是一个更基本的误解。堆栈上的每个positive_negative实例都有自己的pos和neg值。这些从0.0开始，然后向它们添加0.0或list_changes[0]，然后调用一个不影响它们的函数，然后返回它们。因此，您最终将返回0.0, list_changes[0]或list_changes[0], 0.0;列表后面的内容永远不会影响结果。

如果您希望递归函数调用添加任何内容，则需要对其返回值执行某些操作。像这样：

def positive_negative(list_changes):
    if len(list_changes)== 0:
        return 0.0, 0.0
    else:
        pos, neg = positive_negative(list_changes[1:])
        if list_changes[0] > 0.0:
            pos += list_changes[0]
        else:
            neg += list_changes[0]
        return pos, neg

当然这个解决方案显然不是尾递归的......但这并不重要，因为无论如何Python都不进行尾递归优化。我认为这是你想要完成的最接近的解决方案。

Answer 2

使用一些累加器（psum，nsum）：

def positive_negative(list_changes, psum=0, nsum=0):
    if len(list_changes) == 0:
            return psum, nsum
    if list_changes[0] < 0:
            nsum += list_changes[0]
    else:
            psum += list_changes[0]
    return positive_negative(list_changes[1:], psum, nsum)

# and another version:
def positive_negative2(list_changes, psum=0, nsum=0):
    if len(list_changes) == 0:
            return psum, nsum
    if list_changes[0] < 0:
            return positive_negative(list_changes[1:], 
                            psum, nsum + list_changes[0])
    return positive_negative(list_changes[1:], 
                            psum + list_changes[0], nsum)

print positive_negative([0.01, 0.03, -0.02, -0.14, 0, 0, 0.10, -0.01])

<强>输出

(0.14, -0.17)

作为旁注，python不进行尾调用优化，因此在使用递归时要小心。如果您的列表中包含大约1000个项目，则上述功能将失败。

Answer 3

不使用尾递归：

import operator


def positive_negative_change(l):
    if not l:
        return (0.0, 0.0)

    if l[0] >= 0:
        return tuple(map(operator.add, (l[0], 0.0),
                         positive_negative_change(l[1:])))
    else:
        return tuple(map(operator.add, (0.0, l[0]),
                         positive_negative_change(l[1:])))

在python中

会使用生成器或尾递归... 如果你要刷新递归，请阅读小阴谋

python中的递归技术而不是列表技术

3 个答案: