The numpy.reshape() function shapes an array without changing the data of the array.

Syntax: `numpy.reshape(array, shape, order = 'C')`

Parameters :

```
array : [array_like]Input array
shape : [int or tuples of int] e.g. if we are aranging an array with 10 elements then shaping
it like numpy.reshape(4, 8) is wrong; we can do numpy.reshape(2, 5) or (5, 2)
order : [C-contiguous, F-contiguous, A-contiguous; optional]
C-contiguous order in memory(last index varies the fastest)
C order means that operating row-rise on the array will be slightly quicker
FORTRAN-contiguous order in memory (first index varies the fastest).
F order means that column-wise operations will be faster.
‘A’ means to read / write the elements in Fortran-like index order if,
array is Fortran contiguous in memory, C-like order otherwise
```

Return :

Array which is reshaped without changing the data.

Example:

```
# Python Program illustrating
# numpy.reshape() method
import numpy as geek
# array = geek.arrange(8)
# The 'numpy' module has no attribute 'arrange'
array1 = geek.arange(8)
print("Original array : \n", array1)
# shape array with 2 rows and 4 columns
array2 = geek.arange(8).reshape(2, 4)
print("\narray reshaped with 2 rows and 4 columns : \n",array2)
# shape array with 4 rows and 2 columns
array3 = geek.arange(8).reshape(4, 2)
print("\narray reshaped with 2 rows and 4 columns : \n",array3)
# Constructs 3D array
array4 = geek.arange(8).reshape(2, 2, 2)
print("\nOriginal array reshaped to 3D : \n",
array4)
```

Output :

```
Original array :
[0 1 2 3 4 5 6 7]
array reshaped with 2 rows and 4 columns :
[[0 1 2 3]
[4 5 6 7]]
array reshaped with 4 rows and 2 columns :
[[0 1]
[2 3]
[4 5]
[6 7]]
Original array reshaped to 3D :
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
[[0 1 2 3]
[4 5 6 7]]
```