List Comprehension In Reverse Order With Python

How do you perform a list comprehension in reverse using Python?

A list comprehension is generally a short one line code that allows you to create a new list by iterating through an iterator (such as another list).

The syntax for a list comprehension is [expression for variable in iterable if condition] with the if condition part being optional.

The easiest way to perform a reverse iteration is to use the reversed() function on the iterable so that the list comprehension syntax is written as: [expression for variable in reversed(iterable)] .

A quick example of this is shown as below:

>>> [x for x in reversed([1, 2, 3, 4, 5])]
[5, 4, 3, 2, 1]

If you would like to explore other options on how to perform a reversal in a list comprehension then continue reading below.

Basic Syntax of List Comprehension

List comprehension is a concise way to create lists, and it can also be used to apply operations, filters or conditional statements to the elements of a list. To create a list using list comprehension, you can use the following syntax:

[expression for variable in iterable]
  • expression is the operation or transformation to be applied to each element in the iterable
  • variable is the variable that takes values from the iterable
  • iterable is a sequence of elements (list, tuple, string) to loop over

You can also add filters or conditional statements to control which elements are included in the new list:

[expression for variable in iterable if condition]
  • condition is a boolean expression that must be true for the element to be included in the new list
  • if statement is optional, and can be omitted if there’s no condition to test

For example, let’s say you have a list of numbers from 1 to 5, and you want to create a new list with their squares:

squares = [x**2 for x in [1, 2, 3, 4, 5]]

The result will be:

squares = [1, 4, 9, 16, 25]

This is equivalent to:

squares = []
for x in [1, 2, 3, 4, 5]:

However, list comprehension is more concise and more readable, especially for simple operations.

Reversing List Using reversed()

The first method of reversing a list is by using the reversed() function, which returns a reverse iterator.

The reversed() function takes an iterable (i.e., list, tuple, set, etc.) and returns an iterator object that produces the items in the reverse order.

Example of reversed()

Here is an example using the reversed() function to reverse a list:

>>> lst = [1, 2, 3, 4, 5]
>>> reversed_lst = list(reversed(lst))
>>> print(reversed_lst)
[5, 4, 3, 2, 1]

In this example, we first define a sample list lst and then use the reversed() function to reverse it. To get the reversed list as a new list object, we then pass the reversed iterator to the list() constructor.

Now, the new variable reversed_lst holds the reversed version of the original list, which we then print using the print() function.

Using the reversed() function is a simple and efficient way to reverse a list, especially for large lists. However, note that this method does not modify the original list object itself.

Reversing List Using Slicing

Slicing is a powerful technique used to extract a part of a sequence (string, list, tuple) in Python. It defines a portion of the sequence to be extracted with the help of two indices: start and stop.

The basic syntax of slicing is as follows:


The start index is the position from where the slicing starts. It is inclusive. The stop index is the position where slicing stops. It is exclusive. The step specifies the increment between values in the sliced sequence. It is optional, and by default, it is 1.

To reverse a list using slicing, you need to provide -1 as the step value. This helps extract the list elements in reverse order.


In this syntax, -1 represents the step, which works as a reverse iterator. It moves from right to left in the original list and extracts values in reverse order.


Here is an example of reversing a list using slicing:

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
reversed_fruits = fruits[::-1]


['elderberry', 'date', 'cherry', 'banana', 'apple']

In this example, I defined a list called 'fruits' that contains some fruits. Then, I used slicing to reverse the order of the list and saved it in another variable called 'reversed_fruits' . Finally, I printed the 'reversed_fruits' list, which contains the same elements as 'fruits' but in reverse order.

Using Slice To Reverse List Comprehension

Using the slice operator to reverse a list comprehension can be seen in the following example:

>>> lst = [1, 2, 3, 4, 5]
>>> [x for x in lst[::-1]]
[5, 4, 3, 2, 1]

Using slicing to reverse a list is a powerful technique and can be useful in a variety of situations.


To reverse a list in a list comprehension use the reversed() function or the slice operator [::-1] . By using either of these methods you will be able to change the iteration order of your list to produce the desired result in one line of Python code.

Photo of author
Ryan Sheehy
Ryan has been dabbling in code since the late '90s when he cut his teeth exploring VBA in Excel. Having his eyes opened with the potential of automating repetitive tasks, he expanded to Python and then moved over to scripting languages such as HTML, CSS, Javascript and PHP.