NumPy is a fundamental package for scientific computing in Python. It provides powerful array objects that enable fast mathematical and logical operations on multidimensional array data. One of the key features of NumPy is its broad set of array transformation methods that allow efficient manipulations and analysis of arraybased data. This guide will provide an indepth look at the various array transformation capabilities in NumPy.
Table of Contents
Open Table of Contents
Overview of Array Transformations
Array transformations refer to operations that modify arrays in some way, such as changing their shape, manipulating their values, or rearranging their dimensions. NumPy provides a wide variety of functions and methods to transform arrays for tasks like statistical analysis, machine learning, linear algebra, image processing, and more.
Some common types of array transformations in NumPy include:

Reshaping  Changing the shape of an array by altering the number of rows and columns. This allows you to view the data in different ways without changing the underlying data.

Transposing  Permuting the axes of a multidimensional array to swap rows and columns. This is useful for converting columnoriented data to roworiented or vice versa.

Broadcasting  Expanding smaller arrays to fit the shape of larger arrays to allow elementwise operations between differently sized arrays.

Concatenation  Joining multiple arrays together by stacking them horizontally (columnwise) or vertically (rowwise).

Splitting  Dividing an array into multiple smaller subarrays.

Sorting  Rearranging the elements of an array into a particular order such as ascending or descending.

Subsetting  Extracting specific rows, columns, or elements from an array to obtain a subset of the data.
Let’s look at how to use NumPy for some common array transformation tasks.
Reshaping Arrays
The reshape
method allows you to alter the shape of an array without changing its data. It takes a tuple specifying the new shape and returns a new array with the requested shape:
import numpy as np
arr = np.arange(6)
# [0 1 2 3 4 5]
arr.reshape(3, 2)
# [[0 1]
# [2 3]
# [4 5]]
The new shape must match the number of elements in the original array. You can use 1 to infer one of the dimensions automatically based on the length of the array:
arr.reshape(3, 1)
# [[0 1]
# [2 3]
# [4 5]]
Reshaping is useful for changing 1D arrays into 2D arrays or matrices for further analysis.
Transposing Arrays
The transpose
method permutes the dimensions of an array, effectively swapping rows and columns:
arr = np.arange(6).reshape(2, 3)
# [[0 1 2]
# [3 4 5]]
arr.transpose()
# [[0 3]
# [1 4]
# [2 5]]
For a 2D array, transpose()
is equivalent to flipping the rows and columns. For higher dimensional arrays, it swaps the last and second to last axis.
Transposing is handy for converting columnoriented data to roworiented or vice versa. It is commonly used in linear algebra and matrix operations.
Broadcasting Arrays
Broadcasting allows elementwise binary operations (add, subtract, multiply, etc.) between arrays of different shapes by expanding one array to match the shape of the other:
a = np.arange(3) # [0 1 2]
b = np.arange(6).reshape(2, 3)
# [[0 1 2]
# [3 4 5]]
a + b
# [[0 2 4]
# [3 5 7]]
Here a
is broadcasted across the rows to align its shape with b
before adding.
Broadcasting follows a strict set of rules but generally works by extending dimensions of length 1 in the smaller array to match the larger array. This provides a convenient vectorized approach to operating on differently sized arrays.
Concatenating and Splitting Arrays
numpy.concatenate
allows joining multiple arrays together by stacking them horizontally (columnwise) or vertically (rowwise):
a = np.arange(3) # [0 1 2]
b = np.arange(3, 6) # [3 4 5]
np.concatenate([a, b])
# [0 1 2 3 4 5]
np.concatenate([a, b], axis=None) # equivalent to above
np.concatenate([a, b], axis=0)
# [[0 1 2]
# [3 4 5]]
The axis
parameter controls the direction of stacking. axis=0
stacks vertically while axis=1
stacks horizontally.
Conversely, numpy.split
allows dividing an array into multiple subarrays:
c = np.arange(6) # [0 1 2 3 4 5]
np.split(c, 3)
# [array([0, 1]), array([2, 3]), array([4, 5])]
np.split(c, [2, 4])
# [array([0, 1]), array([2, 3]), array([4, 5])]
You can specify indices to split on or a number of splits to divide the array evenly.
Concatenation and splitting enable managing chunks of data as smaller arrays.
Sorting Arrays
NumPy’s sort
method sorts the elements of an array inplace:
arr = np.random.randint(10, size=6) # sample random array
# [5 9 3 7 2 1]
arr.sort()
# [1 2 3 5 7 9]
By default sort
uses quicksort to sort numbers in ascending order. Other key parameters include:
axis
 Axis to sort along in multidimensional arrayskind
 Sort algorithm like ‘quicksort’, ‘mergesort’, ‘heapsort’order
 Sort order like ‘ascending’ or ‘descending’
Sorting is useful for arranging data in a particular order before further analysis.
Subsetting Arrays
NumPy offers various methods to extract subsets of data from arrays:
Slicing:
arr = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
arr[2:5]
# [2 3 4]
Slicing provides a subset by defining a start and stop index separated by a colon.
Boolean indexing:
arr = np.arange(10)
arr[arr > 5]
# [6 7 8 9]
A boolean array or mask can be used to select elements where the condition is True.
Fancy indexing:
arr = np.arange(10)
ind = [3, 1, 2]
arr[ind]
# [3 1 2]
Fancy indexing selects elements explicitly by index position.
These methods enable extracting and filtering relevant data from arrays for particular use cases.
Practical Examples
Here are some examples of how array transformations are applied in realworld scenarios:
Machine learning: Reshaping a 28x28 image array into a 784x1 array for input into a neural network. Transposing feature and target matrices in model training.
# Reshape 2D image to 1D vector
image = np.arange(784).reshape(28, 28)
image_vector = image.reshape(784, 1)
# Transpose feature and target arrays
X = features.transpose()
y = targets.transpose()
Linear algebra: Transposing a matrix to solve a system of equations. Concatenating vector arrays for matrix operations.
# Solve linear system Ax = b
A = np.arange(4).reshape(2, 2)
b = np.array([1, 1])
x = np.linalg.solve(A.transpose(), b)
# Column vectors to matrix
x1 = np.arange(2)
x2 = np.arange(2, 4)
X = np.concatenate([x1, x2], axis=1)
Data analysis: Reshaping an array from wide to long format for time series analysis. Sorting arrays to rank data. Subsetting arrays to filter data.
# Reshape wide to long
data = np.arange(6).reshape(2, 3)
data_long = data.reshape(6, 1)
# Sort by descending revenue
revenues = [500, 400, 1200, 90, 150]
sort_indices = np.argsort(revenues)[::1]
# Filter ages above 50
ages = [32, 15, 67, 40, 24]
ages_filt = ages[ages < 50]
Conclusion
In summary, NumPy provides a versatile set of array transformation capabilities that are essential for scientific computing tasks in Python. Mastering methods like reshaping, transposing, broadcasting, concatenating, sorting, and subsetting arrays enables efficient data manipulations for downstream analysis and modeling. With its speed, multidimensional array support, and expressive syntax, NumPy is the fundamental starting point for working with numeric data in Python.