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

Extended slice syntax is explained here. See also, documentation.

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

Or

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

Summary of Methods with Explanation and Timing Results

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