Data Manipulation in Numpy¶

NumPy offers a variety of functions for manipulating arrays, allowing you to reshape, join, split, and modify data efficiently. Mastering these data manipulation techniques is essential for data analysis, machine learning, and scientific computing.

Importing NumPy¶

Before you start working with NumPy, you need to import the library. It's standard practice to import NumPy using the alias np.

In [1]:

import numpy as np

import numpy as np

This allows you to access NumPy functions using the np prefix, such as np.array().

Array Shape and Reshaping¶

Understanding Array Shapes¶

The shape of an array is a tuple that gives you the size of the array in each dimension.

In [2]:

# Creating a 2D array
array_2d = np.array([[1, 2, 3], [4, 5, 6]])

# Getting the shape of the array
array_shape = array_2d.shape

# Creating a 2D array array_2d = np.array([[1, 2, 3], [4, 5, 6]]) # Getting the shape of the array array_shape = array_2d.shape

In this example, array_shape will be (2, 3), indicating that the array has 2 rows and 3 columns.

Reshaping Arrays (reshape)¶

The reshape function allows you to change the shape of an array without changing its data.

In [3]:

# Creating a 1D array with 6 elements
array_1d = np.arange(6)

# Reshaping the array to 2 rows and 3 columns
array_reshaped = array_1d.reshape(2, 3)
array_reshaped

# Creating a 1D array with 6 elements array_1d = np.arange(6) # Reshaping the array to 2 rows and 3 columns array_reshaped = array_1d.reshape(2, 3) array_reshaped

Out[3]:

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

Here, array_reshaped will be a 2x3 array. The total number of elements must remain the same when reshaping.

3.3 Flattening Arrays (flatten and ravel)¶

Flattening an array converts it into a 1D array.

• flatten returns a copy of the array collapsed into one dimension.
• ravel returns a view (if possible) of the array collapsed into one dimension.

In [27]:

# Flattening the array using flatten()
flattened_array = array_reshaped.flatten()

# Flattening the array using ravel()
raveled_array = array_reshaped.ravel()
flattened_array

# Flattening the array using flatten() flattened_array = array_reshaped.flatten() # Flattening the array using ravel() raveled_array = array_reshaped.ravel() flattened_array

Out[27]:

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

Use flatten when you need a copy of the array, and ravel when you need a view (which is more memory-efficient).

Transposing Arrays (transpose and T)¶

Transposing an array swaps its dimensions.

In [5]:

# Transposing the array using transpose()
transposed_array = array_reshaped.transpose()

# Transposing the array using the T attribute
transposed_array_T = array_reshaped.T

# Transposing the array using transpose() transposed_array = array_reshaped.transpose() # Transposing the array using the T attribute transposed_array_T = array_reshaped.T

Both methods will swap the rows and columns of the array.

Joining Arrays¶

Joining or combining arrays allows you to merge multiple arrays into one.

Concatenation (concatenate)¶

The concatenate function joins a sequence of arrays along an existing axis.

In [28]:

# Creating two arrays
array_a = np.array([[1, 2], [3, 4]])
array_b = np.array([[5, 6]])

# Concatenating along axis 0 (rows)
concatenated_array = np.concatenate((array_a, array_b), axis=0)

# Creating two arrays array_a = np.array([[1, 2], [3, 4]]) array_b = np.array([[5, 6]]) # Concatenating along axis 0 (rows) concatenated_array = np.concatenate((array_a, array_b), axis=0)

Here, concatenated_array will have the new array appended as a new row.

Stacking Arrays (stack, hstack, vstack, dstack)¶

Vertical Stack (vstack)¶

Stacks arrays vertically (row-wise).

In [35]:

# Stacking arrays vertically
vertical_stack = np.vstack((array_a, array_b))
array_a.shape

# Stacking arrays vertically vertical_stack = np.vstack((array_a, array_b)) array_a.shape

Out[35]:

(2, 2)

Horizontal Stack (hstack)¶

Stacks arrays horizontally (column-wise).

In [8]:

# Stacking arrays horizontally
array_c = np.array([[7], [8]])
horizontal_stack = np.hstack((array_a, array_c))

# Stacking arrays horizontally array_c = np.array([[7], [8]]) horizontal_stack = np.hstack((array_a, array_c))

Depth Stack (dstack)¶

Stacks arrays along the third axis (depth).

In [37]:

# Stacking arrays depth-wise
depth_stack = np.dstack((array_a, array_a))
depth_stack

# Stacking arrays depth-wise depth_stack = np.dstack((array_a, array_a)) depth_stack

Out[37]:

array([[[1, 1],
        [2, 2]],

       [[3, 3],
        [4, 4]]])

Generic Stack (stack)¶

Stacks arrays along a new axis.

In [41]:

# Stacking arrays along a new axis
stacked_array = np.stack((array_a, array_a), axis=0)

# Stacking arrays along a new axis stacked_array = np.stack((array_a, array_a), axis=0)

Splitting Arrays¶

Splitting arrays allows you to divide an array into multiple sub-arrays.

Splitting Arrays (split, hsplit, vsplit, dsplit)¶

Split (split)¶

Splits an array into multiple sub-arrays along a specified axis.

In [11]:

# Creating an array
array_d = np.array([1, 2, 3, 4, 5, 6])

# Splitting the array into three equal-sized sub-arrays
split_arrays = np.split(array_d, 3)

# Creating an array array_d = np.array([1, 2, 3, 4, 5, 6]) # Splitting the array into three equal-sized sub-arrays split_arrays = np.split(array_d, 3)

Horizontal Split (hsplit)¶

Splits an array horizontally (column-wise).

In [12]:

# Creating a 2D array
array_e = np.array([[1, 2, 3], [4, 5, 6]])

# Splitting the array into three columns
h_split_arrays = np.hsplit(array_e, 3)

# Creating a 2D array array_e = np.array([[1, 2, 3], [4, 5, 6]]) # Splitting the array into three columns h_split_arrays = np.hsplit(array_e, 3)

Vertical Split (vsplit)¶

Splits an array vertically (row-wise).

In [13]:

# Splitting the array into two rows
v_split_arrays = np.vsplit(array_e, 2)

# Splitting the array into two rows v_split_arrays = np.vsplit(array_e, 2)

Depth Split (dsplit)¶

Splits an array along the depth (third) axis.

In [14]:

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

# Splitting the array along depth
d_split_arrays = np.dsplit(array_f, 2)

# Creating a 3D array array_f = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # Splitting the array along depth d_split_arrays = np.dsplit(array_f, 2)

Adding and Removing Elements¶

NumPy provides functions to insert, append, and delete elements in arrays.

Inserting Elements (insert)¶

The insert function allows you to insert values into an array at specified indices.

In [15]:

# Creating an array
array_g = np.array([1, 2, 3, 4, 5])

# Inserting value 99 at index 2
array_with_insert = np.insert(array_g, 2, 99)

# Creating an array array_g = np.array([1, 2, 3, 4, 5]) # Inserting value 99 at index 2 array_with_insert = np.insert(array_g, 2, 99)

Appending Elements (append)¶

The append function adds values to the end of an array.

In [16]:

# Appending value 6 to the array
array_with_append = np.append(array_g, 6)

# Appending value 6 to the array array_with_append = np.append(array_g, 6)

Deleting Elements (delete)¶

The delete function removes elements at specified indices.

In [17]:

# Deleting the element at index 1
array_with_delete = np.delete(array_g, 1)

# Deleting the element at index 1 array_with_delete = np.delete(array_g, 1)

Copying and Viewing Arrays¶

Understanding how copying works in NumPy is important to avoid unintended side effects.

No Copy at All¶

Assigning an array to a new variable does not create a copy; both variables point to the same data.

In [18]:

# Assigning array_g to array_h
array_h = array_g

# Assigning array_g to array_h array_h = array_g

Modifying array_h will affect array_g.

View or Shallow Copy¶

A view creates a new array object that looks at the same data.

In [19]:

# Creating a view of array_g
array_view = array_g.view()

# Creating a view of array_g array_view = array_g.view()

Changes to the data in the view will affect the original array.

Deep Copy¶

A deep copy creates a new array and copies the data.

In [20]:

# Creating a deep copy of array_g
array_copy = array_g.copy()

# Creating a deep copy of array_g array_copy = array_g.copy()

Modifying array_copy will not affect array_g.

Broadcasting¶

Broadcasting allows NumPy to perform operations on arrays of different shapes.

Understanding Broadcasting Rules¶

• If the arrays do not have the same rank, prepend the shape with ones until both shapes have the same length.
• The size of each dimension should be the same or one of them should be one.

Broadcasting Examples¶

In [42]:

# Creating arrays of different shapes
array_i = np.array([1, 2, 3])
array_j = np.array([[4], [5], [6]])

# Adding arrays using broadcasting
broadcast_sum = array_i + array_j
broadcast_sum

# Creating arrays of different shapes array_i = np.array([1, 2, 3]) array_j = np.array([[4], [5], [6]]) # Adding arrays using broadcasting broadcast_sum = array_i + array_j broadcast_sum

Out[42]:

array([[5, 6, 7],
       [6, 7, 8],
       [7, 8, 9]])

In this example, array_i is reshaped to (1, 3) and array_j to (3, 1). Broadcasting allows the addition to proceed.

Sorting Arrays¶

Sorting arrays is a common operation in data analysis.

Simple Sorting (sort)¶

The sort function returns a sorted copy of an array.

In [22]:

# Creating an unsorted array
array_k = np.array([3, 1, 2])

# Sorting the array
sorted_array = np.sort(array_k)

# Creating an unsorted array array_k = np.array([3, 1, 2]) # Sorting the array sorted_array = np.sort(array_k)

Argsort (argsort)¶

The argsort function returns the indices that would sort an array.

In [23]:

# Getting the indices that would sort the array
sorted_indices = np.argsort(array_k)

# Getting the indices that would sort the array sorted_indices = np.argsort(array_k)

Using sorted_indices, you can rearrange another array to correspond with the sorted order.

Stay Up-to-Date

Sign up for the AI Learning Hub Newsletter to receive the latest updates, new tutorial releases, and valuable insights on AI, directly to your inbox.