Section 1.1: Reshaping Arrays

Reshaping lets you alter the configuration of an array without modifying its data, providing a flexible approach to view and access your data in various formats. In NumPy, this transformation is executed through several methods, including reshape, flatten, and ravel. We will explore these functions through practical examples, highlighting their differences and primary applications.

The numpy.reshape(a, newshape) function is the most frequently utilized for reshaping. It enables you to specify a new shape for an array without affecting its data. Here, a refers to the array being reshaped, and newshape is a tuple of integers that defines the target shape.

For instance, consider a straightforward 1-dimensional array:

import numpy as np

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

print(arr)

We can transform this 1D array into a 2D array, for example, with 2 rows and 4 columns:

np.reshape(arr, (2, 4))

This results in:

array([[1, 2, 3, 4],

[5, 6, 7, 8]])

Alternatively, we could reshape it into 4 rows and 2 columns:

np.reshape(arr, (4, 2))

This yields:

array([[1, 2],

[3, 4],

[5, 6],

[7, 8]])

Additionally, we can directly invoke the reshape method on the array:

arr.reshape(4, 2)

This also provides the same output.

Reshaping isn't confined to 2 dimensions; we can also create a 3D array with the shape 2x2x2:

arr.reshape(2, 2, 2)

This results in:

array([[[1, 2],

[3, 4]],

[[5, 6],

[7, 8]]])

However, it’s crucial to ensure that the total number of elements remains consistent. The above example works because 8 equals 2 x 4, which is also equal to 2 x 2 x 2. An incompatible shape, such as:

arr.reshape(2, 3)

will raise an exception.

A helpful shortcut in reshaping is the use of -1, which acts as a placeholder indicating that NumPy should infer that dimension based on the array's total size. For instance, if we don't know the exact number of columns but want 2 rows, we can use:

arr.reshape(2, -1)

This results in:

array([[1, 2, 3, 4],

[5, 6, 7, 8]])

Here, -1 serves as a placeholder for the required number of columns.

Similarly, we can reshape using:

arr.reshape(-1, 2)

This produces:

array([[1, 2],

[3, 4],

[5, 6],

[7, 8]])

This placeholder approach also allows for flattening a multidimensional array into a one-dimensional array:

arr2 = arr.reshape(2, -1)

arr2.reshape(-1)

This outputs:

array([1, 2, 3, 4, 5, 6, 7, 8])

This technique proves beneficial for performing matrix multiplications on multidimensional grids. Similar results can be achieved with the flatten function:

arr2.flatten()

or by using the ravel function:

arr2.ravel()

Both yield:

array([1, 2, 3, 4, 5, 6, 7, 8])

While flatten and ravel perform nearly identical tasks, a critical distinction exists: flatten returns a copy of the original array, while ravel returns a view of the original array when possible. This characteristic makes ravel more memory-efficient, but modifications to the output array can impact the original.

It's important to note that reshaping returns a copy of the original data:

arr2 = arr.reshape(2, 4)

print(id(arr) == id(arr2))

This will output False, indicating that the reshaped array is distinct from the original.

Section 1.2: Stacking Arrays

Stacking in NumPy is the process of merging multiple arrays along a designated axis. This can be accomplished through various methods, depending on the desired output.

Let's begin with vertical stacking. The simplest way to illustrate this is through an example. Consider two basic 1-dimensional arrays:

import numpy as np

arr1 = np.array([0, 1, 2, 3])

arr2 = np.array([4, 5, 6, 7])

Now, we can stack these arrays vertically:

arr_stacked = np.vstack((arr1, arr2))

This results in:

array([[0, 1, 2, 3],

[4, 5, 6, 7]])

The vstack function treats arr1 and arr2 as row vectors and stacks them vertically, one on top of the other. Note that vstack requires a tuple of arrays as an argument, necessitating the additional parentheses.

We can also stack more than two arrays:

np.vstack((arr1, arr2, arr1, arr2))

This gives:

array([[0, 1, 2, 3],

[4, 5, 6, 7],

[0, 1, 2, 3],

[4, 5, 6, 7]])

Now, if we define our 1D arrays as column vectors:

np.vstack((arr1.reshape(-1, 1), arr2.reshape(-1, 1)))

This results in:

array([[0],

[1],

[2],

[3],

[4],

[5],

[6],

[7]])

vstack again stacks them intuitively.

Stacking isn't limited to 1D arrays; you can utilize any dimensionality. For example:

arr3 = np.arange(8).reshape(2, -1)

arr4 = np.arange(8, 16).reshape(2, -1)

np.vstack((arr3, arr4))

This yields:

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11],

[12, 13, 14, 15]])

The only requirement is that all dimensions, except the first (rows), must be the same.

Now, let's explore horizontal stacking, achieved with the hstack function. This function works similarly to vstack, but instead of stacking rows, it appends arrays side by side, along axis 1. To illustrate:

print(f'arr1 = {arr1}, arr2 = {arr2}')

np.hstack((arr1, arr2))

This gives:

array([0, 1, 2, 3, 4, 5, 6, 7])

For two-dimensional arrays:

print(f'arr3: n{arr3}narr4:n{arr4}')

np.hstack((arr3, arr4))

Results in:

array([[ 0, 1, 2, 3, 8, 9, 10, 11],

[ 4, 5, 6, 7, 12, 13, 14, 15]])

Additionally, NumPy provides row_stack and column_stack, which function identically to vstack and hstack, respectively.

Thus far, we have examined vertical (stacking along axis 0) and horizontal (stacking along axis 1) stacking. However, NumPy also allows stacking along any axis using the stack function. You simply provide the arrays to be stacked and specify the axis. For example:

np.stack((arr1, arr2), axis=0)

This results in:

array([[0, 1, 2, 3],

[4, 5, 6, 7]])

If we stack along axis 1:

np.stack((arr1, arr2, arr2), axis=1)

This gives:

array([[0, 4, 4],

[1, 5, 5],

[2, 6, 6],

[3, 7, 7]])

For a 2D array:

arr5 = np.arange(8).reshape(2, 4)

np.stack((arr5, 2*arr5, 3*arr5), axis=2).shape

This results in a shape of (2, 4, 3).

Section 1.3: Splitting Arrays

Splitting is another vital operation in NumPy, essentially serving as the inverse of stacking. It divides a larger array into smaller subsets, with various methods available depending on your requirements.

The split function is the fundamental method for this operation. Its syntax is numpy.split(arr, indices_or_sections, axis=0), where arr is the array to be split, indices_or_sections can either be an integer, indicating the number of equal arrays to create, or a 1-D array of points where to split. The axis parameter specifies the axis along which to split, defaulting to 0.

For example:

arr = np.array([0, 1, 2, 3, 4, 5])

np.split(arr, 2, axis=0)

This results in:

[array([0, 1, 2]), array([3, 4, 5])]

Note that this works only because the original array size is even along axis 0. If we try:

arr = np.array([0, 1, 2, 3, 4, 5, 6])

np.split(arr, 2, axis=0)

An exception will occur! However, we can use alternative syntax to define split points:

arr = np.array([0, 1, 2, 3, 4, 5, 6])

np.split(arr, [3], axis=0)

This results in:

[array([0, 1, 2]), array([3, 4, 5, 6])]

Or:

np.split(arr, [3, 5], axis=0)

This gives:

[array([0, 1, 2]), array([3, 4]), array([5, 6])]

What does axis=0 imply? For a 1-dimensional array, there is only one axis (axis 0), so splitting along this axis is the default behavior.

For multi-dimensional arrays, specifying the axis is crucial. For example, consider a 2D array:

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(arr)

This outputs:

[[1 2 3]

[4 5 6]

[7 8 9]]

If we split along axis 0 (rows):

print(np.split(arr, 3, axis=0))

The result will be:

[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]

If we split along axis 1 (columns):

print(np.split(arr, 3, axis=1))

This gives:

[array([[1],

[4],

[7]]), array([[2],

[5],

[8]]), array([[3],

[6],

[9]])]

In this case, splitting along axis 0 produces three arrays, each containing one of the original array's rows. Conversely, splitting along axis 1 results in three arrays, each containing one of the original array's columns.

Like stacking, there are also convenience functions hsplit and vsplit, which perform splitting along axis 1 and 0, respectively.