如何在Python中反转列表？

如何在Python中执行以下操作

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

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

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

扩展切片语法在Python中得到了很好的解释

根据评论中的特殊要求。

您可以使用此功能：

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

请注意，

reversed（…）

不会返回列表。您可以使用

list（reversed（array））

获得反向列表

或

---

将您的需求最直接地翻译成Python的是以下

for

语句：

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

---

这相当神秘，但可能很有用。

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

array.reverse()

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

newArray = array[::-1] 

---

严格地说，问题不在于如何反向返回列表，而在于如何使用示例列表名

array

反向返回列表

>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

要反转名为

“array”

的列表，请使用

array.reverse（）

---

通过使用

array=array[：：-1]

使用列表理解将列表定义为自身的切片修改，还可以使用所描述的非常有用的切片方法来反转列表：

[array[n] for n in range(len(array)-1, -1, -1)]

---

如果要将反转列表的元素存储在其他变量中，则可以使用

revArray=array[：：-1]

或

revArray=list（反转（数组））

但第一种变体速度稍快：

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))

输出：

Time: 0.00489711761475 s
Time: 0.00609302520752 s

使用反向（数组）可能是最好的方法

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

如果您需要了解如何在不使用内置的

反向

的情况下实现此功能

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）个时间。

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

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

---

使用切片，例如array=array[：：-1]，是一个非常巧妙的技巧，非常有吸引力，但对于新手来说可能有点晦涩难懂。使用reverse（）方法是进行日常编码的好方法，因为它易于阅读

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

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]

---

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

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

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 

>>> 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]

我发现（与其他一些建议相反，

l.reverse（）

是迄今为止在Python3和Python2中反转长列表的最快方法。我很想知道其他人是否可以复制这些时间安排

l[：：-1]

速度可能较慢，因为它会在反转列表之前复制列表。在

reversed（l）

所做的迭代器周围添加

list（）

调用必须增加一些开销。当然，如果您想要列表的副本或迭代器，则使用相应的方法，但如果您只想反转列表，则

l.reverse（）

似乎是最快的方法

功能

def rev_list1(l):
    return l[::-1]

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

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

名单

Python 3.5计时

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

Python2.7计时

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

您还可以使用数组索引的顺序反向单步遍历数组：

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

---

无论你做什么，都不要这样做；）

可以使用返回生成器的

\uuuuu reverse\uuuu

来完成

>>> l = [1,2,3,4,5]
>>> for i in l.__reversed__():
...   print i
... 
5
4
3
2
1
>>>

与及：

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

前后交换号码。使用两个指针

index[0]和index[last]

def反转（阵列）：
n=阵列
第一个=0
last=len（数组）-1
当第一个<最后一个：
持有人=n[第一]
n[第一]=n[最后]
n[最后]=持有人
第一+=1
最后-=1
返回n
输入->[-1,1,2,3,4,5,6]
输出->[6,1,2,3,4,5，-1]

具有最少的内置功能，假设是面试设置

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

使用

---

一行代码中用户输入值的反向：

for i in input()[::-1]: print(i,end='')

---

另一个解决方案是使用此方法

---

有3种方法可获得反向列表：

切片方法1:

reversed\u array=array[-1:：-1]

切片方法2：

reversed\u array2=数组[：-1]

使用内置函数：

reversed\u array=array.reverse（）

第三个函数实际上颠倒了列表对象的位置。这意味着不保留原始数据的副本。如果您不想维护旧版本，这是一个很好的方法。但是，如果您确实想要原始版本和反向版本，这似乎不是一个解决方案。

方法摘要，包括解释和计时结果 有三种不同的内置方法可以反转列表。哪种方法最好取决于您是否需要：

原地反转现有列表（更改原始列表变量）

• 最佳解决方案是

  object.reverse（）

  method

创建反向列表的迭代器（因为您将把它提供给for循环、生成器等）

• 最佳解决方案是创建迭代器的

  反向（对象）

按相反顺序创建列表的副本（以保留原始列表）

• 最佳解决方案是使用步长为-1的切片：

  对象[：：-1]

从速度的角度来看，最好使用内置函数来反转列表。在这种情况下，它们在短距离l上的速度要快2到8倍

l = list(range(1000000))

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

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

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

>>> l = [1,2,3,4,5]
>>> for i in l.__reversed__():
...   print i
... 
5
4
3
2
1
>>>

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

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]

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

print(reversed(list_name))

for i in input()[::-1]: print(i,end='')

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

print(sorted(my_list, reverse=True))

or

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

print(list(reversed(my_list)))