Reversing an array means changing the order of the elements. The first element becomes the last, the second becomes the second-to-last, and so on, and finally, the last becomes the first.

For example, if an array has “n” elements, then the element at index i moves to index n-1-i. So, if an array has [1, 2, 3, 4] elements, the reversed array becomes [4, 3, 2, 1]. You can see that it is a mirror image of the original array.

Here are the ways to reverse a Numpy array:

1. Using slicing (an Efficient way)
2. Using numpy.flip()
3. Using numpy.flipud()

Method 1: Using slicing arr[::-1]

The slicing arr[::-1] is the most efficient way to create a reverse array because you create a view into an original array. You can modify the original array; the view will update to reflect the changes.

import numpy as np

arr = np.arange(5)
print(arr)

print('After reversing the array using [::-1]: ')
print(arr[::-1])

# [0 1 2 3 4]
# After reversing the array using [::-1]:
# [4 3 2 1 0]

The arr[::-1] just returns the reversed view. Slicing does not create a new array in memory, and it avoids overhead copying the data. This is the reason this approach is blazing fast.

This method is concise, efficient, and brief. However, the array is not contiguous in memory (e.g., due to striding or other advanced slicing), so a copy might be created.

Method 2: Using numpy.flip()

The numpy.flip() method reverses the order of elements in an array along the specified axis, creating a new array in memory.

import numpy as np

main_arr = np.array([11, 21, 19, 18])

print(main_arr)

reversed_arr = np.flip(main_arr)

print('After reversing the array using np.flip(): ')

print(reversed_arr)


# [11 21 19 18]

# After reversing the array using np.flip():

# [18 19 21 11]

Here, you can see from the output that we get a new reversed array with flipped elements.

Its intent is clear to reverse an array. However, it creates a new array in memory, which is less efficient than slicing for larger arrays.

Method 3: Using numpy.flipud()

The numpy.flipud() method helps reverse the numpy array along axis 0 (up or down).

import numpy as np

main_arr = np.array([11, 21, 19, 18])

print(main_arr)

reversed_arr = np.flipud(main_arr)

print('After reversing the array using np.flipud(): ')

print(reversed_arr)

# [11 21 19 18]

# After reversing the array using np.flipud():

# [18 19 21 11]

It is more readable than the np.flip() method and is designed explicitly for flipping arrays along the vertical axis (axis 0). However, it only works for flipping along the vertical axis.

Reversing a Two-dimensional numpy array

To reverse the two-dimensional array from left to right, you can use the “np.fliplr()” method.

import numpy as np

main_arr_2d = np.array([[11, 21], [19, 18]])

print(main_arr_2d)

reversed_2d_arr = np.fliplr(main_arr_2d)

print('After reversing 2D array using np.fliplr(): ')

print(reversed_2d_arr)

# [[11 21]
#  [19 18]]

# After reversing 2D array using np.fliplr():

# [[21 11]
#  [18 19]]

Reversing a multi-dimensional numpy array

We will reverse a multi-dimensional array along a specific axis.

import numpy as np

main_multi_arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # 3D array

# Reverse along axis 0
reversed_axis0 = main_multi_arr[::-1, :, :]
reversed_axis0_flip = np.flip(main_multi_arr, axis=0)

# Reverse along axis 1
reversed_axis1 = main_multi_arr[:, ::-1, :]
reversed_axis1_flip = np.flip(main_multi_arr, axis=1)

# Reverse along both axis 0 and 2
reversed_both = main_multi_arr[::-1, :, ::-1]
reversed_both_flip = np.flip(main_multi_arr, axis=(0, 2))

print("Original array:\n", main_multi_arr)
print("\nReversed along axis 0:\n", reversed_axis0)
print("\nReversed along axis 1:\n", reversed_axis1)
print("\nReversed along both axis 0 and 2:\n", reversed_both)

Output

That’s all!