# Reversing a List in Python

Python provides us with various ways of reversing a list. We will go through some of the many techniques on how a list in Python can be reversed.

Example:

```Input: list = [4, 5, 6, 7, 8, 9]
Output: [9, 8, 7, 6, 5, 4]
Explanation: The list we are having in the output is reversed to the list we have in the input.

```

## Reversing a List in Python

### 1. Reverse List Using Slicing Technique

In this technique, a copy of the list is made, and the list is not sorted in place. Creating a copy requires more space to hold all the existing elements. This exhausts more memory. Here we are using the slicing technique to reverse our list in Python.

## Python3

 `# Reversing a list using slicing technique``def` `Reverse(lst):``   ``new_lst ``=` `lst[::``-``1``]``   ``return` `new_lst`  `lst ``=` `[``10``, ``11``, ``12``, ``13``, ``14``, ``15``]``print``(Reverse(lst))`

Output
```[15, 14, 13, 12, 11, 10]

```

Time complexity: O(n)
Auxiliary space: O(n)

### 2. Reverse List by Swapping Present and Last Numbers at a Time

Here is the approach:

If the arr[], size if the length of the array is 1, then return arr. elif length of the array is 2, swap the first and last number and return arr. otherwise, initialize i=0. Loop for i in size//2 then swap the first present and last present numbers if the first and next numbers indexes are not same, then swap next and last of next numbers then increment i+=2, and after looping return arr.

## Python3

 `#Python program to reverse an array``def` `list_reverse(arr,size):` `    ``#if only one element present, then return the array``    ``if``(size``=``=``1``):``        ``return` `arr``    ` `    ``#if only two elements present, then swap both the numbers.``    ``elif``(size``=``=``2``):``        ``arr[``0``],arr[``1``],``=``arr[``1``],arr[``0``]``        ``return` `arr``    ` `    ``#if more than two elements presents, then swap first and last numbers.``    ``else``:``        ``i``=``0``        ``while``(i

Output
```Original list:  [1, 2, 3, 4, 5]
Reversed list:  [5, 4, 3, 2, 1]

```

Time Complexity: O(log2(n)), where n is the length of the given array.
Auxiliary Space: O(1)

### 3. Reverse List Using the Reversed() and Reverse() Built-In Function

Using reversed() we can reverse the list and a list_reverseiterator object is created, from which we can create a list using list() type casting. Or, we can also use the list reverse() function to reverse list in place.

## Python3

 `lst ``=` `[``10``, ``11``, ``12``, ``13``, ``14``, ``15``]``lst.reverse()``print``(``"Using reverse() "``, lst)` `print``(``"Using reversed() "``, ``list``(``reversed``(lst)))`

Output
```Using reverse()  [15, 14, 13, 12, 11, 10]
Using reversed()  [10, 11, 12, 13, 14, 15]

```

Time complexity: O(n), where n is the length of the list lst.
Auxiliary space: O(1) since it modifies the original list in place and does not create a new list.

### 4. Reverse a List Using a Two-Pointer Approach

In this method, we will declare two pointers(basically the start index and the end index, let ‘left’ and ‘right’). While scanning the list, in each iteration we will swap the elements at index ‘left’ and ‘right’.

The ‘left’ pointer will move forward and the ‘right’ pointer will move backward. We will continue the process till ‘first’ < ‘last’. This will work for both an even number of elements as well an odd number of elements.

## Python3

 `# Reversing a list using two-pointer approach``def` `reverse_list(arr):``    ``left ``=` `0``    ``right ``=` `len``(arr)``-``1``    ``while` `(left < right):``        ``# Swap``        ``temp ``=` `arr[left]``        ``arr[left] ``=` `arr[right]``        ``arr[right] ``=` `temp``        ``left ``+``=` `1``        ``right ``-``=` `1` `    ``return` `arr` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``]``print``(reverse_list(arr))`

Output
```[7, 6, 5, 4, 3, 2, 1]

```

Time Complexity: O(N)
Auxiliary Space: O(1)

### 5. Reverse a List Using the insert() Function

In this method, we neither reverse a list in place (modify the original list) nor create any copy of the list. Instead, we keep inserting items at the 0th index of the list, this will automatically reverse the list.

## Python3

 `# input list``lst ``=` `[``10``, ``11``, ``12``, ``13``, ``14``, ``15``]``# the above input can also be given as``# lst=list(map(int,input().split()))``l ``=` `[]  ``# empty list` `# iterate to reverse the list``for` `i ``in` `lst:``    ``# reversing the list``    ``l.insert(``0``, i)``# printing result``print``(l)`

Output
```[15, 14, 13, 12, 11, 10]

```

Time complexity: O(n)
Auxiliary Space: O(n), where n is the length of the list.

### 6. Reverse a List Using List Comprehension

In this technique, the list is not sorted in place. A copy of the original array is not required. We use list comprehension to reverse the array and return the list.

We find the length of the array and then iterate over it using the range. Now, to replace the last element with the first, we subtract the length of the original list from the index of the iterator.

## Python3

 `original_list ``=` `[``10``, ``11``, ``12``, ``13``, ``14``, ``15``]``new_list ``=` `[original_list[``len``(original_list) ``-` `i]``            ``for` `i ``in` `range``(``1``, ``len``(original_list)``+``1``)]``print``(new_list)`

Output
```[15, 14, 13, 12, 11, 10]

```

Time complexity: O(n), where n is the length of the original_list.
Auxiliary space: O(n),

### 7. Reverse a List Using Numpy

Here we are going to use numpy package:

Initialize the input list my_listConvert my_list to a 1D numpy array using np.array(my_list)Reverse the order of the array using my_array[::-1]Convert the reversed numpy array back to a list using .tolist()

Print the reversed list

## Python3

 `import` `numpy as np` `# Input list``my_list ``=` `[``4``, ``5``, ``6``, ``7``, ``8``, ``9``]` `# Convert the list to a 1D numpy array``my_array ``=` `np.array(my_list)` `# Reverse the order of the array``reversed_array ``=` `my_array[::``-``1``]` `# Convert the reversed array to a list``reversed_list ``=` `reversed_array.tolist()` `# Print the reversed list``print``(reversed_list)`

Output:

```[9, 8, 7, 6, 5, 4]

```

Time complexity: O(n)
Auxiliary space: O(n)

We have discussed many ways of reversing a list in Python. We have also mentioned their time complexities and Auxiiary space to give you right idea about their processing speed.

Hope this article helped you to understand ways on “how to reverse a python list?” and you will easily reverse a list in Python.

Previous
Next