如何在python中反转列表？


How can I reverse a list in Python?

如何在Python中执行以下操作？

1
2
array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

我需要一个数组的元素，但是从头到尾。

1
2
3
>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

扩展片语法在python中很好地解释了发行版2.3.5的新条目是什么。

通过注释中的特殊请求，这是最新的切片文档。

相关讨论

您可以将reversed函数用于此目的，如下所示：

1
2
3
>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

注意，reversed(...)不返回列表。您可以使用list(reversed(array))得到一个颠倒的列表。

相关讨论

1
2
3
4
>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

或

1
2
>>> L[::-1]
[40, 20, 10, 0]
相关讨论

这是为了复制列表：

1
2
L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

这是为了将列表倒过来：

1
L.reverse() # Here L will be reversed in-place (no new list made)

我认为在python中反转列表的最佳方法是：

1
2
3
4
a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

工作完成了，现在您有了一个颠倒的列表。

相关讨论

要反转相同的列表，请使用：

1
array.reverse()

要将反向列表分配到其他列表中，请使用：

1
newArray = array[::-1]
相关讨论

使用切片，例如array=array[：：-1]是一个很好的技巧，而且非常适合于Python，但对新手来说可能有点模糊。使用reverse()方法是进行日常编码的一个好方法，因为它易于阅读。

但是，如果您需要像在面试问题中那样颠倒一个列表，那么您可能无法使用像这样的内置方法。面试官将关注你是如何处理问题的，而不是如何深入了解Python知识，因此需要一种算法方法。下面的示例，使用经典交换，可能是一种方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print"Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

注意，这对元组或字符串序列不起作用，因为字符串和元组是不可变的，也就是说，您不能写入它们来更改元素。

相关讨论

1
2
for x in array[::-1]:
    do stuff
相关讨论

我发现(与其他一些建议相反)在Python3和Python2中，l.reverse()是迄今为止逆转长列表的最快方法。我想知道其他人是否可以复制这些时间安排。

l[::-1]可能会慢一些，因为它在反转列表之前复制了列表。在reversed(l)所做的迭代器周围添加list()调用必须增加一些开销。当然，如果您想要一个列表或迭代器的副本，然后使用这些各自的方法，但是如果您只想反转列表，那么l.reverse()似乎是最快的方法。

功能

1
2
3
4
5
6
7
8
9
def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

表

1
l = list(range(1000000))

python 3.5计时

1
2
3
4
5
6
timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

python 2.7计时

1
2
3
4
5
6
timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46
相关讨论

使用reversed和list时：

1
2
3
4
>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

可能的方式，

1
2
3
4
5
list1 = [3,4,3,545,6,4,34,243]

list1.reverse()

list1[::-1]
1
2
3
array=[0,10,20,40]
for e in reversed(array):
  print e

使用反向(数组)可能是最好的路由。

1
2
3
>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

如果您需要了解如何在不使用内置的reversed的情况下实现这一点。

1
2
3
4
5
6
7
8
def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

这需要O(N)时间。

相关讨论

如果要将反转列表的元素存储在其他变量中，那么可以使用revArray = array[::-1]或revArray = list(reversed(array))。

但第一种变体速度稍快：

1
2
3
4
5
6
7
8
9
z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

输出：

1
2
Time: 0.00489711761475 s
Time: 0.00609302520752 s
相关讨论

使用列表理解：

1
[array[n] for n in range(len(array)-1, -1, -1)]
组织价值观：

在python中，也可以通过排序来操纵列表的顺序，将变量按数字/字母顺序组织：

暂时：

1
print(sorted(my_list))

永久的：

1
my_list.sort(), print(my_list)

您可以使用"Reverse=true"标志进行排序：

print(sorted(my_list, reverse=True))

or

my_list.sort(reverse=True), print(my_list)

没有组织

也许您不想对值排序，但只想反转这些值。然后我们可以这样做：

print(list(reversed(my_list)))

**按列表顺序，数字优先于字母表。python的价值观组织非常棒。

您可以使用reversed()。

1
2
3
4
array=[0,10,20,40]

for e in reversed(array):
  print e

严格来说，问题不在于如何反向返回一个列表，而在于如何反向返回一个示例列表名为array的列表。

要反转名为"array"的列表，请使用array.reverse()。

如前所述，非常有用的slice方法也可用于通过使用array = array[::-1]将列表定义为对其自身的切片修改来反转列表。

相关讨论

1
2
3
4
5
def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

还可以使用数组索引的按位补码反向单步执行数组：

1
2
3
>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

不管你做什么，不要这样做。

使用反向功能如下并打印

1
2
>>> for element in reversed(your_array):
...     print element

您可以将列表视为一个堆栈，只需从列表的后端将元素从堆栈顶部弹出即可。这样就可以利用堆栈的先进先出特性。当然，您正在使用第一个数组。我很喜欢这种方法，因为它非常直观，因为您可以看到一个列表从后端消耗，而另一个列表是从前端构建的。

1
2
3
4
5
>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]
1
2
3
4
5
6
7
def reverse(text):
    lst=[]
    for i in range(0,len(text)):
        lst.append(text[(len(text)-1)-i])
    return ''.join(lst)

print reverse('reversed')
相关讨论

1
2
3
4
5
6
7
8
9
list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print"After Rev:- %s" %rev_data

将您的需求直接转换为python的最直接的方法是下面的for语句：

1
2
for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

这很神秘，但可能有用。

1
2
3
4
5
def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list
使用一些逻辑

用一些老派的逻辑来练习面试。

Swapping numbers front to back. Using two pointers index[0] and index[last]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]
相关讨论

1
2
3
>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]
相关讨论

通过切换相反索引的引用来就地反转：

1
2
3
4
5
6
>>> l = [1,2,3,4,5,6,7]    
>>> for i in range(len(l)//2):
...     l[i], l[-1-i] = l[-1-i], l[i]
...
>>> l
[7, 6, 5, 4, 3, 2, 1]
相关讨论

可以使用返回生成器的__reverse__来完成。

1
2
3
4
5
6
7
8
9
10
>>> l = [1,2,3,4,5]
>>> for i in l.__reversed__():
...   print i
...
5
4
3
2
1
>>>
1
2
3
4
>>> L = [1, 2, 3, 4]
>>> L = [L[-i] for i in range(1, len(L) + 1)]
>>> L
[4, 3, 2, 1]