python堆栈反向输出列表_如何在Python中反转列表？

回答(30)

2 years ago

我发现(与其他一些建议相反) l.reverse() 是迄今为止在Python 3和2中反转长列表的最快方法 . 我有兴趣知道其他人是否可以复制这些时间 .

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

名单

l = list(range(1000000))

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

Python 2.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

2 years ago

对于倒转相同的列表使用：

array.reverse()

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

newArray = array[::-1]

2 years ago

def reverse(text):

output = []

for i in range(len(text)-1, -1, -1):

output.append(text[i])

return output

2 years ago

def reverse(text):

lst=[]

for i in range(0,len(text)):

lst.append(text[(len(text)-1)-i])

return ''.join(lst)

print reverse('reversed')

2 years ago

>>> L = [0,10,20,40]

>>> L[::-1]

[40, 20, 10, 0]

2 years ago

您可以始终将列表视为堆栈，只是从列表的后端弹出堆栈顶部的元素 . 这样你就可以利用堆栈中的第一个特征 . 当然你正在使用第一个阵列 . 我喜欢这种方法，因为它非常直观，因为你看到一个列表从后端消耗而另一个列表是从前端构建的 .

>>> l = [1,2,3,4,5,6]; nl=[]

>>> while l:

nl.append(l.pop())

>>> print nl

[6, 5, 4, 3, 2, 1]

2 years ago

使用 reversed 功能如下并打印

>>> for element in reversed(your_array):

... print element

2 years ago

可以使用 __reverse__ 来完成，它返回一个生成器 .

>>> l = [1,2,3,4,5]

>>> for i in l.__reversed__():

... print i

...

5

4

3

2

1

>>>

2 years ago

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

2 years ago

组织 Value 观：

在Python中，列表的顺序也可以使用 sort 进行操作，以数字/字母顺序组织变量：

暂时：

print(sorted(my_list))

永久：

my_list.sort(), print(my_list)

您可以使用标志 "reverse=True" 进行排序：

print(sorted(my_list，reverse = True))或my_list.sort(reverse = True)，print(my_list)

没有组织

也许您不想对值进行排序，而只是反转值 . 然后我们可以这样做：

print(list(reversed(my_list)))

**在列表顺序中，数字优先于字母 . Python值的组织非常棒 .

2 years ago

>>> L = [1, 2, 3, 4]

>>> L = [L[-i] for i in range(1, len(L) + 1)]

>>> L

[4, 3, 2, 1]

2 years ago

>>> list1 = [1,2,3]

>>> reversed_list = list(reversed(list1))

>>> reversed_list

>>> [3, 2, 1]

2 years ago

array=[0,10,20,40]

for e in reversed(array):

print e

2 years ago

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

a = [1,2,3,4]

a = a[::-1]

print(a)

>>> [4,3,2,1]

工作完成了，现在你有一个反向列表 .

2 years ago

你可以使用 reversed()

array=[0,10,20,40]

for e in reversed(array):

print e

2 years ago

使用列表理解：

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

2 years ago

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

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

2 years ago

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

但第一个变种略快一些：

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

2 years ago

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

2 years ago

您可以将reversed函数用于此：

>>> array=[0,10,20,40]

>>> for i in reversed(array):

... print(i)

请注意 reversed(...) 不返回列表 . 您可以使用 list(reversed(array)) 获得反向列表 .

2 years ago

严格来说，问题不在于如何反向返回列表，而是如何使用示例列表名称 array 来反转列表 .

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

所描述的非常有用的切片方法也可以用于通过使用 array = array[::-1] 将列表定义为自身的切片修改来反转列表 .

2 years ago

使用切片，例如array = array [:: - 1]，是一个巧妙的技巧，非常Pythonic，但对于新手来说可能有点模糊 . 使用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]

请注意，这不适用于元组或字符串序列，因为字符串和元组是不可变的，即，您无法写入它们来更改元素 .

2 years ago

您还可以使用数组索引的bitwise complement来反向遍历数组：

>>> array = [0, 10, 20, 40]

>>> [array[~i] for i, _ in enumerate(array)]

[40, 20, 10, 0]

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

2 years ago

>>> l = [1, 2, 3, 4, 5]

>>> print(reduce(lambda acc, x: [x] + acc, l, []))

[5, 4, 3, 2, 1]

2 years ago

这是为了复制列表：

L = [0,10,20,40]

p = L[::-1] # Here p will be having reversed list

这是为了反转列表：

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

2 years ago

for x in array[::-1]:

do stuff

2 years ago

将您的需求最直接地转换为Python是 for 语句：

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

print i, array[i]

这是相当神秘的，但可能有用 .

2 years ago

>>> L = [0,10,20,40]

>>> L.reverse()

>>> L

[40, 20, 10, 0]

要么

>>> L[::-1]

[40, 20, 10, 0]

2 years ago

可能的方式，

list1 = [3,4,3,545,6,4,34,243]

list1.reverse()

list1[::-1]

2 years ago

使用反转(数组)可能是最佳路线 .

>>> array = [1,2,3,4]

>>> for item in reversed(array):

>>> print item

您是否需要了解如何在不使用内置 reversed 的情况下实现此目的 .

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)时间 .