Python 递归地反转列表

我创建了一个递归反转列表的函数，但它使用了一个全局列表来放置元素。 可以重写它，这样它就不会使用外部变量/列表来获得相同的结果

代码如下：

invs = []

def inv_list(list_, elem):
    global invs

    if elem is not None:
        invs.append(elem) 

    if not list_:
        return invs

    else:
        try:
            el = list_.pop()
            inv_list(list_, el)

        except Exception:
            pass

那么：

def inv_list(lst):
    if not lst:
        return []
    return inv_list(lst[1:]) + lst[:1]

---

看起来你做的工作比你需要的多得多

def reverse_recurse(a_list):
    if not a_list:
        return []
    return [a_list.pop(),] + reverse_recurse(a_list)

有问题的方法很简单，只需使用默认参数

def rec_reverse(input=[], output=[]):
    if len(input) == 0:
        return
    else:
        output.append(input.pop())
        rec_reverse(input, output)
        return output

x = list(range(10))
y = list(range(20))
print(rec_reverse(x, []))
print(rec_reverse(y, []))

只需记住向输出传递一个新列表，这样您就可以再次调用它，而不会得到旧值

但是，您可以使用安全方法而不使用默认参数：

def rec_reverse(input):
    if not input:
        return input
    else:
        return [input.pop(), ] + rec_reverse(input)

您还可以将其递归等价物用作lambda表达式：

rec_reverse = lambda input=[]: [] if not input else [input.pop(), ] + rec_reverse(input)

但是请记住，有一个更简单的解决方案根本不使用递归：

x = list(range(10))
rec_reverse = lambda input: input[::-1]
print(rec_reverse(x))

因为在Python中，您可以使用来反转任何列表

此外，您可以使用倒档，省去了麻烦

def reverse(input):
    input.reverse()
    return input

---

虽然您的实现可以通过各种方式进行改进，但当我发现我想要构建一些递归的东西而不使用全局函数，并且不使接口感觉脏时，我需要创建一个嵌套的帮助器函数：

def inv_list(list_):
    invs = []

    def helper(elem):
        if elem is not None:
            invs.append(elem) 

        if not list_:
            return invs
        else:
            try:
                el = list_.pop()
                return helper(el)
            except Exception:
                pass

    return helper(None)

def inv_list(list_):
    def inner(list_, invs):
        if not list_:
            return invs
        else:
            invs.append(list_.pop())
            return inner(list_, invs)

    return inner(list_, [])

---

这样，您就可以拥有外部函数范围内的值。

基于Rederick Deathwill，这里是您函数的简化版本：

def inv_list(list_):
    invs = []

    def helper(elem):
        if elem is not None:
            invs.append(elem) 

        if not list_:
            return invs
        else:
            try:
                el = list_.pop()
                return helper(el)
            except Exception:
                pass

    return helper(None)

def inv_list(list_):
    def inner(list_, invs):
        if not list_:
            return invs
        else:
            invs.append(list_.pop())
            return inner(list_, invs)

    return inner(list_, [])

它使用invs的默认值，不需要全局变量来保存倒排列表。在后续调用中，invs被传递，以便下一个调用可以在其上构建

一旦到达调用堆栈的底部，函数将返回反向列表。对原始列表的一个很好的补充是returninnerlist，invs行，它允许调用者捕获新列表作为返回值

---

这不是最短的，但我认为它至少是可读的。

或者返回lst if not lst else lst lst[-1:]+inv_listlst[：-1]@padraiccningham我喜欢使用lst[-1:]而不是[lst[-1]]的想法！。相反，我认为当lst为空时，返回空列表的副本而不是原始lst是正确的。否则您的行为会不一致EP，您还可以返回[]if not lst else lst[-1:]+inv_listlst[：-1]将列表用作参数为什么不使用反向方法？值得指出的是，使用列表作为默认函数参数是有问题的，因为每次使用默认参数时都会返回相同的实例。尝试调用函数两次。