Edited Python Numpy built-in functions .reshape()

content/numpy/concepts/built-in-functions/terms/reshape/reshape.md

@@ -58,3 +58,43 @@ This produces the following output:
  [5]
  [6]]
 ```
+
+Optionally, a third parameter can be added to the syntax: `order`.
+
+`order` reads the elements from `array` in the current index order and places the elements into the reshaped array using the same index order. It can be set to `'C'`, `'F'`, or `'A'`. `C` means to read/write the elements using C-like index order, or in other words, the elements are placed row by row. The last axis index (columns) changes first (fastest), and the first axis index (rows) changes afterward (slowest). `F` means to read/write the elements using Fortran-like index order, where the elements are placed column by column. Here, the first axis index (rows) changes faster while the last axis index (columns) changes slower. Using `C` or `F` in `.reshape()` means that the function is only reshaping the way that indexes are placed in the array, and not like data physically stored in the computer memory (memory layout). `A` means to read/write the elements in Fortran-like index order if `array` is Fortran contiguous in memory, meaning, in a sequencial and continuous manner without gaps between elements, or in C-like index order otherwise.
+
+```pseudo
+numpy.reshape(array, newshape, order = 'C')
+```
+
+The following example creates an `ndarray` then uses `order` as an optional parameter for `.reshape()` to change its dimensions.
+
+```py
+import numpy as np
+
+nd1 = np.array([[10, 20, 30], [40, 50, 60]])
+
+print(nd1)
+print(np.reshape(nd1, (3, 2), order='C')) # row by row
+print(np.reshape(nd1, (3, 2), order='F')) # column by column
+```
+
+This produces the following output:
+
+```shell
+[[10 20 30]
+ [40 50 60]]
+
+
+[[10 20]
+ [30 40]
+ [50 60]]
+
+
+[[10 50]
+ [40 30]
+ [20 60]]
+```
+
+> [!Note]
+> The last output just reflects the natural behaviour from Fortran indexation order