# How do I reverse a list or loop over it backwards?

## Question:

How do I iterate over a list in reverse in Python?

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

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

``````for x in array[::-1]:
do stuff
``````

To get a new reversed list, apply the `reversed` function and collect the items into a `list`:

``````>>> xs = [0, 10, 20, 40]
>>> list(reversed(xs))
[40, 20, 10, 0]
``````

To iterate backwards through a list:

``````>>> xs = [0, 10, 20, 40]
>>> for x in reversed(xs):
...     print(x)
40
20
10
0
``````

Use `list.reverse` to reverse a list in-place:

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

Use slices to create a new list with the items in reverse order:

``````>>> xs[::-1]
[40, 20, 10, 0]
``````
``````array=[0,10,20,40]
for e in reversed(array):
print e
``````

The most direct translation of your requirement into Python is this `for` statement:

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

This is rather cryptic but may be useful.

For reversing the same list use:

``````array.reverse()
``````

To assign reversed list into some other list use:

``````newArray = array[::-1]
``````

The question is not how to return a list in reverse but rather how to reverse a list with an example list name `array`.

To reverse a list named `"array"` use `array.reverse()`.

The incredibly useful slice method as described can also be used to reverse a list in place by defining the list as a sliced modification of itself using `array[:] = array[::-1]`.

Use list comprehension:

``````[array[n] for n in range(len(array)-1, -1, -1)]
``````
``````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
``````

If you want to store the elements of reversed list in some other variable, then you can use `revArray = array[::-1]` or `revArray = list(reversed(array))`.

But the first variant is slightly faster:

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

Output:

``````Time: 0.00489711761475 s
Time: 0.00609302520752 s
``````
``````>>> L = [1, 2, 3, 4]
>>> L = [L[-i] for i in range(1, len(L) + 1)]
>>> L
[4, 3, 2, 1]
``````
``````def reverse(text):
output = []
for i in range(len(text)-1, -1, -1):
output.append(text[i])
return output
``````

Using reversed(array) would be the likely best route.

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

Should you need to understand how could implement this without using the built in `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
``````

This should take O(N) time.

You could always treat the list like a stack just popping the elements off the top of the stack from the back end of the list. That way you take advantage of first in last out characteristics of a stack. Of course you are consuming the 1st array. I do like this method in that it’s pretty intuitive in that you see one list being consumed from the back end while the other is being built from the front end.

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

Using slicing, e.g. array = array[::-1], is a neat trick and very Pythonic, but a little obscure for newbies maybe. Using the reverse() method is a good way to go in day to day coding because it is easily readable.

However, if you need to reverse a list in place as in an interview question, you will likely not be able to use built in methods like these. The interviewer will be looking at how you approach the problem rather than the depth of Python knowledge, an algorithmic approach is required. The following example, using a classic swap, might be one way to do it:-

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

Note that this will not work on Tuples or string sequences, because strings and tuples are immutable, i.e., you cannot write into them to change elements.

``````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]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]
``````

Reversing in-place by switching references of opposite indices:

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

I find (contrary to some other suggestions) that `l.reverse()` is by far the fastest way to reverse a long list in Python 3 and 2. I’d be interested to know if others can replicate these timings.

`l[::-1]` is probably slower because it copies the list prior to reversing it. Adding the `list()` call around the iterator made by `reversed(l)` must add some overhead. Of course if you want a copy of the list or an iterator then use those respective methods, but if you want to just reverse the list then `l.reverse()` seems to be the fastest way.

Functions

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

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

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

List

``````l = list(range(1000000))
``````

Python 3.5 timings

``````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 timings

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

You can also use the bitwise complement of the array index to step through the array in reverse:

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

Whatever you do, don’t do it this way ðŸ˜‰

Can be done using `__reverse__` , which returns a generator.

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

With `reversed` and `list`:

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

## Using some logic

Using some old school logic to practice for interviews.

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

``````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, 5, 4, 3, 2, 1, -1]
``````

With minimum amount of built-in functions, assuming it’s interview settings

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

use

``````print(list(reversed(list_name)))
``````

Reverse of a user input values in one line code:

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

This class uses Python magic methods and iterators for reversing, and reverses a list:

``````class Reverse(object):
""" Builds a reverse method using magic methods """

def __init__(self, data):
self.data = data
self.index = len(data)

def __iter__(self):
return self

def __next__(self):
if self.index == 0:
raise StopIteration

self.index = self.index - 1
return self.data[self.index]

REV_INSTANCE = Reverse([0, 10, 20, 40])

iter(REV_INSTANCE)

rev_list = []
for i in REV_INSTANCE:
rev_list.append(i)

print(rev_list)
``````

### Output

``````[40, 20, 10, 0]
``````

Here’s a way to lazily evaluate the reverse using a generator:

``````def reverse(seq):
for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
yield seq[x] #Yield a value to the generator
``````

Now iterate through like this:

``````for x in reverse([1, 2, 3]):
print(x)
``````

If you need a list:

``````l = list(reverse([1, 2, 3]))
``````

Another solution would be to use numpy.flip for this

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

There are 3 methods to get the reversed list:

1. Slicing Method 1: `reversed_array = array[-1::-1]`

2. Slicing Method 2:
`reversed_array2 = array[::-1]`

3. Using the builtin function: `reversed_array = array.reverse()`

The third function actually reversed the list object in place. That means no copy of pristine data is maintained. This is a good approach if you don’t want to maintain the old version. But doesn’t seem to be a solution if you do want the pristine and reversed version.

## Summary of Reverse Methods

There are three different built-in ways to reverse a list. Which method is best depends on whether you need to:

1. Reverse an existing list in-place (altering the original list variable)
• Best solution is `object.reverse()` method
2. Create an iterator of the reversed list (because you are going to feed it to a for-loop, a generator, etc.)
• Best solution is `reversed(object)` which creates the iterator
3. Create a copy of the list, just in the reverse order (to preserve the original list)
• Best solution is using slices with a -1 step size: `object[::-1]`

From a speed perspective, it is best to use the above built-in functions to reverse a list. For reversing, they are 2 to 8 times faster on short lists (10 items), and up to ~300+ times faster on long lists compared to a manually-created loop or generator. This makes sense – they are written in a native language (i.e. C), have experts creating them, scrutiny, and optimization. They are also less prone to defects and more likely to handle edge and corner cases.

### Test Script

Put all the code snippets in this answer together to make a script that will run the different ways of reversing a list that are described below. It will time each method while running it 100,000 times. The results are shown in the last section for lists of length 2, 10, and 1000 items.

``````from timeit import timeit
from copy import copy

def time_str_ms(t):
return '{0:8.2f} ms'.format(t * 1000)
``````

## Method 1: Reverse in place with obj.reverse()

If the goal is just to reverse the order of the items in an existing list, without looping over them or getting a copy to work with, use the `<list>.reverse()` function. Run this directly on a list object, and the order of all items will be reversed:

Note that the following will reverse the original variable that is given, even though it also returns the reversed list back. i.e. you can create a copy by using this function output. Typically, you wouldn’t make a function for this, but the timing script requires it.

We test the performance of this two ways – first just reversing a list in-place (changes the original list), and then copying the list and reversing it afterward to see if that is the fastest way to create a reversed copy compared to the other methods.

``````def rev_in_place(mylist):
mylist.reverse()
return mylist

def rev_copy_reverse(mylist):
a = copy(mylist)
a.reverse()
return a
``````

## Method 2: Reverse a list using slices `obj[::-1]`

The built-in index slicing method allows you to make a copy of part of any indexed object.

• It does not affect the original object
• It builds a full list, not an iterator

The generic syntax is: `<object>[first_index:last_index:step]`. To exploit slicing to create a simple reversed list, use: `<list>[::-1]`. When leaving an option empty, it sets them to defaults of the first and last element of the object (reversed if the step size is negative).

Indexing allows one to use negative numbers, which count from the end of the object’s index backwards (i.e. -2 is the second to last item). When the step size is negative, it will start with the last item and index backward by that amount.

``````def rev_slice(mylist):
a = mylist[::-1]
return a
``````

## Method 3: Reverse a list with the `reversed(obj)` iterator function

There is a `reversed(indexed_object)` function:

• This creates a reverse index iterator, not a list. Great if you are feeding it to a loop for better performance on large lists
• This creates a copy and does not affect the original object

Test with both a raw iterator, and creating a list from the iterator.

``````def reversed_iterator(mylist):
a = reversed(mylist)
return a

def reversed_with_list(mylist):
a = list(reversed(mylist))
return a
``````

## Method 4: Reverse list with Custom/Manual indexing

As the timing shows, creating your own methods of indexing is a bad idea. Use the built-in methods unless you really do need to do something custom. This simply means learning the built-in methods.

That said, there is not a huge penalty with smaller list sizes, but when you scale up the penalty becomes tremendous. The code below could be optimized, I’m sure, but it can’t ever match the built-in methods as they are directly implemented in a native language.

``````def rev_manual_pos_gen(mylist):
max_index = len(mylist) - 1
return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
## index is 0 to 9, but we need -1 to -10
return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
a = []
reverse_index = len(mylist) - 1
for index in range(len(mylist)):
a.append(mylist[reverse_index - index])
return a

def rev_manual_loop(mylist):
a = []
reverse_index = len(mylist)
for index, _ in enumerate(mylist):
reverse_index -= 1
a.append(mylist[reverse_index])
return a
``````

## Timing each method

Following is the rest of the script to time each method of reversing. It shows reversing in place with `obj.reverse()` and creating the `reversed(obj)` iterator are always the fastest, while using slices is the fastest way to create a copy.

It also proves not to try to create a way of doing it on your own unless you have to!

``````loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
a = copy(list_to_reverse) # copy to start fresh each loop
out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
# Time in ms for the given # of loops on this fcn
time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
# Get the output string for this function
fcn_str = '{}(a):'.format(fcn.__name__)
# Add the correct string length to accommodate the maximum fcn name
format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))
``````

## Timing Results

The results show that scaling works best with the built-in methods best suited for a particular type of reversing. In other words, as the object element count increases, the built-in methods outpace the other methods by even more.

The built-in method that directly achieves what you need does better than stringing things together. i.e. slicing is best if you need a copy of the reversed list – it’s faster than creating a duplicate list from `list(reversed(obj))` function, and faster than making a copy of the list and then doing an in-place `obj.reverse()`, but never by more than double the speed. Meanwhile – custom methods can take orders of magnitude longer with large lists.

For scaling, with a 1000 item list, the `reversed(<list>)` function call takes ~30 ms to setup the iterator, reversing in-place takes just ~55 ms, using the slice method takes ~210 ms to create a copy of the full reversed list, but the quickest manual method I made took ~8400 ms.

With 2 items in the list:

``````a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]
``````

With 10 items in the list:

``````rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

And with 1000 items in the list:

``````rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms
``````

ORGANIZING VALUES:

In Python, lists’ order too can be manipulated with sort, organizing your variables in numerical/alphabetical order:
Temporarily:

print(sorted(my_list))

Permanent:

``````my_list.sort(), print(my_list)
``````

You can sort with the flag "reverse=True":

``````print(sorted(my_list, reverse=True))

or

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

WITHOUT ORGANIZING

Maybe you do not want to sort values, but only reverse the values. Then we can do it like this:

``````print(list(reversed(my_list)))
``````

**Numbers have priority over alphabet in listing order. The Python values’ organization is awesome.

Edit 1: a mistaken moderator claimed that my answer was a copy and deleted my old post.

I had this question come up during a python code test for a job interview.
Note it works for any value any length

``````def get_reverse(list_check, count_num):
final_list =[]
for index in range(list_length):
value = list_check[count_num]
final_list.append(value)
count_num = count_num -1

return final_list

new_list = ['A', 'GOAT', 'C', 'D', 'Mac']

list_length = len(new_list)
x = list_length -1

print(get_reverse(new_list, x))
``````

A clean simple class object to solve your issue.

``````class lister():
def reverse(self):
return  [self[len(self)-e]for e,x in enumerate(self,start=1)]
print(lister.reverse([0, 10, 20, 40]))
``````

alternative way using list comprehension and abs

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

reversed_array = [array[abs(indx)] for indx in range(abs(len(array)-1),1)]

reversed_array
[40, 20, 10, 0]
``````
``````The cute Solution

class List_reverse():
def reverse_list(self):
list = [1, 2, 3, 4, 5, 6]
list1 = []
for i in range(1, len(list)+1):
list1.append(list[-i])
print(list1)

if __name__ == "__main__":
obj = List_reverse()
obj.reverse_list()
enter code here
``````
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.