断言python

Question

我对python中的递归有问题。我的代码看起来像这样：

counter = 0
result = []
def count_inversion(sequence):
    global result, counter
    """
        Count inversions in a sequence of numbers
    """
    sequence = list(sequence)
    if len(sequence) == 1:
        result.append(sequence[0])
        if result == sorted(result):
            result = []
            return counter
        else:
            sequence = result
            result = []
            return count_inversion(sequence)

    if sequence[0] > sequence[1]:
        result.append(sequence.pop(1))
        counter += 1
        return count_inversion(sequence)
    else:
        result.append(sequence[0])
        return count_inversion(sequence[1:])

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert count_inversion((1, 2, 5, 3, 4, 7, 6)) == 3, "Example"
    assert count_inversion((0, 1, 2, 3)) == 0, "Sorted"
    assert count_inversion((99, -99)) == 1, "Two numbers"
    assert count_inversion((5, 3, 2, 1, 0)) == 10, "Reversed"

当我单独运行assert时，它工作得很好，但当我想要一起运行它时，我遇到了问题，变量count仍然具有来自前一个assert的值(在本例中是来自first asser的3)。我不知道在我的代码中把counter =0放在哪里才能正常工作。谢谢。

Answer 1

有两个选项：

选项1:在方法中初始化：

def count_inversion(sequence):
    counter = 0
    result = []
    # Your code

选项2:正如Rawing建议的那样，您可以使用参数：

def count_inversion(sequence, counter, result):
    #your code

你可以这样称呼它：

count_inversion((1, 2, 5, 3, 4, 7, 6), 0, []):

一种更简洁的方法是：

def count_inversion(sequence, counter=0, result=[]):
    #your code

这样，如果您希望这些参数是其他参数，则只需指定这些参数：

count_inversion((1，2，5，3，4，7，6)，counter=1)：#计数器现在从1开始

Answer 2

这将解决您的问题，我删除了计数器作为全局变量，并每次将其传递给函数count_inversion…另一种不推荐使用的解决方案是在return之前设置一个新变量= counter，然后重新设置counter=0，然后返回该新变量

result = []
def count_inversion(sequence, counter):
    global result
    """
       Count inversions in a sequence of numbers
    """
    sequence = list(sequence, counter)
    if len(sequence) == 1:
        result.append(sequence[0])
        if result == sorted(result):
           result = []
           return counter
        else:
           sequence = result
           result = []
           return count_inversion(sequence, counter)

    if sequence[0] > sequence[1]:
        result.append(sequence.pop(1))
        counter += 1
        return count_inversion(sequence, counter)
    else:
        result.append(sequence[0])
        return count_inversion(sequence[1:], counter)

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert count_inversion((1, 2, 5, 3, 4, 7, 6),0) == 3, "Example"
    assert count_inversion((0, 1, 2, 3),0) == 0, "Sorted"
    assert count_inversion((99, -99),0) == 1, "Two numbers"
    assert count_inversion((5, 3, 2, 1, 0),0) == 10, "Reversed"

基于你上面的评论，我添加了保持计数器为全局的代码：

counter=0
result = []
def count_inversion(sequence):
    global result
    global counter
    """
       Count inversions in a sequence of numbers
    """
    sequence = list(sequence)
    if len(sequence) == 1:
        result.append(sequence[0])
        if result == sorted(result):
           result = []
           return_counter=counter
           counter=0
           return return_counter
        else:
           sequence = result
           result = []
           return count_inversion(sequence)

    if sequence[0] > sequence[1]:
        result.append(sequence.pop(1))
        counter += 1
        return count_inversion(sequence)
    else:
        result.append(sequence[0])
        return count_inversion(sequence[1:])

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert count_inversion((1, 2, 5, 3, 4, 7, 6)) == 3, "Example"
    assert count_inversion((0, 1, 2, 3)) == 0, "Sorted"
    assert count_inversion((99, -99)) == 1, "Two numbers"
    assert count_inversion((5, 3, 2, 1, 0)) == 10, "Reversed"

Answer 3

这里是你的函数的一个简化版本，它不会弄乱全局变量：

def count_inversion(sequence, current=(), counter=0):
    """Count inversions in a sequence of numbers."""
    if len(sequence) < 2:
        current += sequence
        if list(current) == sorted(current):
            return counter
        return count_inversion(current, (), counter)
    index = sequence[0] > sequence[1]
    return count_inversion(sequence[:index] + sequence[index+1:],
                           current + sequence[index:index+1],
                           counter + index)

主要区别是：

• 它使用默认参数来跟踪current，而
• 直接使用元组，因此不需要进行列表转换。它通过使用索引(0或1)从

中弹出元素来分解递归调用

输出：

>>> count_inversion((1, 2, 5, 3, 4, 7, 6))
3
>>> count_inversion((0, 1, 2, 3))
0
>>> count_inversion((99, -99))
1
>>> count_inversion((5, 3, 2, 1, 0))
10