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

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] ，这不是我想要完成的。 它只是颠倒了列表的顺序，而不是列表中的实际元素。

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

[ 编辑 ：我的代码需要改变列表; 我不想只打印它，它实际上需要更改列表。]

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

这应该可以解决问题。

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 4

或者，您使用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上的 Blog ，过滤，缩小和映射以了解lambda函数和map()如何在Python中工作。

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的项目，枚举可以帮助解决这个问题，或者您可以使用上面较少优先的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

你可以使这个递归，所以它适用于任意深的巢。

像（UNTESTED）这样的东西：

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)