如何反转子列表中的元素？

Question

我正在尝试创建一个函数来反转列表中元素的顺序，并反转子列表中的元素。例如：

例如，如果 L = [[1, 2], [3, 4], [5, 6, 7]] 则 deep_reverse(L) 将 L 变为 [[7, 6, 5], [4 , 3], [2, 1]]

我想出了如何反转一个列表的顺序，但是我在反转子列表中元素的顺序时遇到了麻烦。这是我目前所拥有的：

def deep_reverse(L)
    """ 
    assumes L is a list of lists whose elements are ints
    Mutates L such that it reverses its elements and also 
    reverses the order of the int elements in every element of L. 
    It does not return anything.
    """
    for i in reversed(L):
          print(i)

在上面的示例中，我的代码只会打印[5,6,7], [3,4], [1,2]，这不是我想要完成的。它只是颠倒列表的顺序，而不是列表中的实际元素。

我应该在代码中添加什么以便它也反转子列表中元素的顺序？

[EDIT：我的代码需要改变列表；我不希望它只是打印它，它实际上需要更改列表。]

Answer 1

[sublist[::-1] for sublist in to_reverse[::-1]]

列表理解在这里有效。 [::-1]与reversed基本相同，只是不修改列表。

编辑：

如下所述，reversed 不会修改列表。它返回一个listreverseiterator 对象

更多编辑：

如果您想要任意深度列表的解决方案，请尝试：

def deep_reverse(to_reverse):
    if isinstance(to_reverse, list):
        return list(map(deep_reverse, to_reverse[::-1]))
    else:
        return to_reverse

更多编辑：

在函数中改变列表：

L[:] = new_list 

将就地修改列表。

Answer 2

我正在尝试创建一个函数来反转列表中元素的顺序，并反转子列表中的元素。

那就做这两件事吧：

L.reverse()
for sublist in L:
    sublist.reverse()

---

完整的演示，因为你似乎对你的函数应该做什么以及如何测试它感到困惑：

>>> def deep_reverse(L):
        """ 
        assumes L is a list of lists whose elements are ints
        Mutates L such that it reverses its elements and also 
        reverses the order of the int elements in every element of L. 
        It does not return anything.
        """
        L.reverse()
        for sublist in L:
            sublist.reverse()

>>> L = [[1, 2], [3, 4], [5, 6, 7]]
>>> deep_reverse(L)
>>> print(L)
[[7, 6, 5], [4, 3], [2, 1]]

Answer 3

您也可以使用map() 来实现：

>>> map(lambda x: x[::-1], L[::-1])       # In Python 2.x
[[7, 6, 5], [4, 3], [2, 1]]

>>> list(map(lambda x: x[::-1], L[::-1])) # In Python 3.x
[[7, 6, 5], [4, 3], [2, 1]]

查看Lambda, filter, reduce and map 上的博客，了解lambda 的功能和map() 在Python 中的工作原理。

Answer 4

这应该可以解决问题。

L = [[1, 2], [3, 4], [5, 6, 7]]

def deep_reverse(L):
    for i in range(len(L)):
        L[i]=L[i][::-1]
    L=L[::-1]
    return L

Answer 5

这看起来很熟悉:)。我不会给出完整的解决方案，但这里有一些提示：

如您所知，有两个步骤，将每个子列表反转，然后将外部列表反转（到位，不创建新列表，因此会变异全局L）。

所以你可以遍历外部列表，并对每个子列表进行变异：

for i in range(len(L)):
    # if L[i] is a list:
        # reverse with [::-1] and update L[i] to the reversed version
# reverse the outer list L, list.reverse() will operate in-place on L

现在请记住，如果您像这样遍历列表：

for item in list:
    item = 'xxx'

你不能用上面的代码改变item。 item 是一个占位符值，因此更改它实际上不会修改列表。

您需要为 L 中的项目编制索引，而 enumerate 可以帮助您解决此问题，或者您可以使用上述不太受欢迎的 range(len())。

for i, item in enumerate(L):
    # do something with L[i]
    L[i] = 'something'

编辑：由于对此有很多困惑，我将继续发布基于 Stefan Pochmann 非常优雅的答案的工作解决方案：

def deep_reverse(L):
    L.reverse()
    for sublist in L:
        sublist.reverse()

请注意，没有 return 语句，也没有 print 语句。这将正确地修改L。您不能在函数内部重新分配L，因为这样它只会创建一个新的本地版本的L，并且不会修改全局L。您可以使用list.reverse() 修改L 就地，根据规范进行必要的修改。

Answer 6

具有功能范式和防御性编程：

def deep_reverse(L):
    """ assumes L is a list of lists whose elements are ints
    Mutates L such that it reverses its elements and also 
    reverses the order of the int elements in every element of L. 
    It does not return anything.
    """
    # Your code here
    for i in L:
        try:
            deep_reverse(i)
        except:
            pass
    L.reverse()

Answer 7

你可以让它递归，所以它适用于任意深度的嵌套。

类似（未测试）：

def deep_reverse(L)
    """ 
    assumes L is a list of lists whose elements are ints
    Mutates L such that it reverses its elements and also 
    reverses the order of the int elements in every element of L. 
    It does not return anything.
    """
    for i in reversed(L):
          if len(i) > 1:
              deep_reverse(i)
          else:
              print(i)