Harsh MishraComprehensive Guide to NumPy: The Ultimate Cheat Sheet
NumPy (Numerical Python) is a fundamental library for scientific computing in Python. It adds support for large multi-dimensional arrays and matrices, along with a vast collection of mathematical functions to operate on these arrays efficiently. NumPy is widely used for data analysis, machine learning, deep learning, and numerical computation.
1. Importing NumPy
Before using NumPy, the library must be imported into your Python environment.
import numpy as np
2. NumPy Arrays
NumPy arrays are the core of the library. They provide fast and efficient storage of large datasets and support vectorized operations.
Creating Arrays
There are several ways to create arrays in NumPy:
1D, 2D, and 3D Array Creation
# 1D array
arr_1d = np.array([1, 2, 3, 4])
# 2D array
arr_2d = np.array([[1, 2], [3, 4], [5, 6]])
# 3D array
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
Expected Output:
1D array: [1 2 3 4]
2D array: [[1 2]
[3 4]
[5 6]]
3D array: [[[1 2]
[3 4]]
[[5 6]
[7 8]]]
3. Array Initialization Functions
Zeros, Ones, Full, Empty, Eye, Identity
These functions create arrays with predefined values.
-
np.zeros(shape)– Returns a new array of given shape filled with zeros. -
np.ones(shape)– Returns a new array filled with ones. -
np.full(shape, fill_value)– Returns a new array of the given shape, filled with a specified value. -
np.empty(shape)– Returns an uninitialized array of the specified shape. -
np.eye(N)– Returns a 2D identity matrix with 1s on the diagonal. -
np.identity(N)– Creates a square identity matrix of size N.
# Creating arrays with initialization functions
zeros_arr = np.zeros((2, 3))
ones_arr = np.ones((2, 2))
full_arr = np.full((3, 3), 7)
eye_arr = np.eye(3)
Expected Output:
Zeros array: [[0. 0. 0.]
[0. 0. 0.]]
Ones array: [[1. 1.]
[1. 1.]]
Full array: [[7 7 7]
[7 7 7]
[7 7 7]]
Identity matrix: [[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
4. Random Array Generation
NumPy provides various ways to generate random numbers.
Random Numbers with np.random
-
np.random.rand(shape)– Generates random values in a given shape (between 0 and 1). -
np.random.randint(low, high, size)– Returns random integers fromlow(inclusive) tohigh(exclusive). -
np.random.choice(array)– Randomly selects an element from an array.
random_arr = np.random.rand(2, 2)
randint_arr = np.random.randint(1, 10, (2, 3))
Expected Output:
Random array: [[0.234 0.983]
[0.456 0.654]]
Random integer array: [[5 7 2]
[3 9 1]]
5. Inspecting and Manipulating Arrays
Array Attributes
-
ndarray.shape– Returns the dimensions of the array. -
ndarray.size– Returns the number of elements in the array. -
ndarray.ndim– Returns the number of dimensions. -
ndarray.dtype– Returns the type of elements in the array. -
ndarray.itemsize– Returns the size of each element in the array (in bytes).
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Shape:", arr.shape)
print("Size:", arr.size)
print("Dimensions:", arr.ndim)
print("Data type:", arr.dtype)
print("Item size:", arr.itemsize)
Expected Output:
Shape: (2, 3)
Size: 6
Dimensions: 2
Data type: int32
Item size: 4
Array Reshaping
-
reshape(shape)– Reshapes the array to a specified shape without changing its data. -
ravel()– Returns a flattened version of the array (1D). -
transpose()– Transposes the array.
reshaped = arr.reshape(3, 2)
flattened = arr.ravel()
transposed = arr.transpose()
Expected Output:
Reshaped array: [[1 2]
[3 4]
[5 6]]
Flattened array: [1 2 3 4 5 6]
Transposed array: [[1 4]
[2 5]
[3 6]]
6. Array Indexing, Slicing, and Modifying Elements
NumPy arrays provide powerful ways to access, slice, and modify data, enabling you to efficiently work with 1D, 2D, and 3D arrays. In this section, we will explore how to access elements and modify arrays using indexing and slicing.
Basic Indexing
You can access elements of an array using square brackets [ ]. Indexing works for arrays of any dimensionality, including 1D, 2D, and 3D arrays.
1D Array Indexing
You can access individual elements of a 1D array by specifying their index.
arr = np.array([1, 2, 3, 4])
print(arr[1]) # Access second element
Expected Output:
2
2D Array Indexing
In a 2D array, you can access elements by specifying the row and column indices. The format is arr[row, column].
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d[1, 2]) # Access element at row 1, column 2
Expected Output:
6
3D Array Indexing
For 3D arrays, you need to specify three indices: depth, row, and column. The format is arr[depth, row, column].
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d[1, 0, 1]) # Access element at depth 1, row 0, column 1
Expected Output:
6
Slicing
Slicing is used to extract subarrays from larger arrays. The syntax for slicing is start:stop:step. The start index is inclusive, while the stop index is exclusive.
1D Array Slicing
You can slice a 1D array by specifying the start, stop, and step indices.
arr = np.array([10, 20, 30, 40, 50])
print(arr[1:4]) # Slicing from index 1 to 3 (exclusive of index 4)
Expected Output:
[20 30 40]
2D Array Slicing
In a 2D array, you can slice both rows and columns. For example, arr[start_row:end_row, start_col:end_col] will slice rows and columns.
arr_2d = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
print(arr_2d[1:3, 0:2]) # Rows from index 1 to 2, Columns from index 0 to 1
Expected Output:
[[40 50]
[70 80]]
3D Array Slicing
For 3D arrays, slicing works similarly by specifying the range for depth, rows, and columns.
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d[1:, 0, :]) # Depth from index 1, Row 0, All columns
Expected Output:
[[5 6]]
Boolean Indexing
Boolean indexing allows you to filter elements based on a condition. The condition returns a boolean array, which is then used to index the original array.
arr = np.array([10, 15, 20, 25, 30])
print(arr[arr > 20]) # Extract elements greater than 20
Expected Output:
[25 30]
Adding, Removing, and Modifying Elements
You can also modify arrays by adding, removing, or altering elements using various functions.
Adding Elements
You can append or insert elements into arrays with the following methods:
-
np.append(arr, values)– Appends values to the end of an array. -
np.insert(arr, index, values)– Inserts values at a specified index. -
np.concatenate([arr1, arr2])– Concatenates two arrays along an existing axis.
arr = np.array([1, 2, 3])
appended = np.append(arr, 4) # Add 4 at the end
inserted = np.insert(arr, 1, [10, 20]) # Insert 10, 20 at index 1
concatenated = np.concatenate([arr, np.array([4, 5])]) # Concatenate arr with another array
Expected Output:
Appended: [1 2 3 4]
Inserted: [ 1 10 20 2 3]
Concatenated: [1 2 3 4 5]
Removing Elements
To remove elements from an array, you can use np.delete().
-
np.delete(arr, index)– Deletes the element at the specified index. -
np.delete(arr, slice)– Deletes elements in a slice of the array.
arr = np.array([1, 2, 3, 4])
deleted = np.delete(arr, 1) # Remove element at index 1
slice_deleted = np.delete(arr, slice(1, 3)) # Remove elements from index 1 to 2 (exclusive of 3)
Expected Output:
Deleted: [1 3 4]
Slice deleted: [1 4]
7. Mathematical Operations
NumPy supports element-wise operations, broadcasting, and a variety of useful mathematical functions.
Basic Arithmetic
You can perform operations like addition, subtraction, multiplication, and division element-wise:
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2) # Element-wise addition
print(arr1 - arr2) # Element-wise subtraction
print(arr1 * arr2) # Element-wise multiplication
print(arr1 / arr2) # Element-wise division
Expected Output:
Addition: [5 7 9]
Subtraction: [-3 -3 -3]
Multiplication: [ 4 10 18]
Division: [0.25 0.4 0.5]
Aggregation Functions
These functions return a single value for an entire array.
-
np.sum(arr)– Returns the sum of array elements. -
np.mean(arr)– Returns the mean of array elements. -
np.median(arr)– Returns the median of array elements. -
np.std(arr)– Returns the standard deviation. -
np.var(arr)– Returns the variance. -
np.min(arr)/np.max(arr)– Returns the minimum/maximum element.
arr = np.array([1, 2, 3, 4, 5])
print(np.sum(arr))
print(np.mean(arr))
print(np.median(arr))
print(np.std(arr))
print(np.min(arr), np.max(arr))
Expected Output:
15
3.0
3.0
1.4142135623730951
1 5
8. Broadcasting and Vectorization
NumPy allows operations between arrays of different shapes via broadcasting, a powerful mechanism for element-wise operations.
Example: Broadcasting
arr = np.array([1, 2, 3])
print(arr + 10) # Broadcasting scalar value 10
Expected Output:
[11 12 13]
9. Linear Algebra in NumPy
NumPy provides many linear algebra functions, such as:
-
np.dot()– Dot product of two arrays. -
np.matmul()– Matrix multiplication. -
np.linalg.inv()– Inverse of a matrix. -
np.linalg.det()– Determinant of a matrix. -
np.linalg.eig()– Eigenvalues and eigenvectors.
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
dot_product = np.dot(A, B)
matrix_mult = np.matmul(A, B)
inv_A = np.linalg.inv(A)
det_A = np.linalg.det(A)
Expected Output:
Dot product: [[19 22]
[43 50]]
Matrix multiplication: [[19 22]
[43 50]]
Inverse of A: [[-2. 1. ]
[ 1.5 -0.5]]
Determinant of A: -2.0
10. Other Useful Functions
Sorting
-
np.sort(arr)– Returns a sorted array.
arr = np.array([3, 1, 2])
sorted_arr = np.sort(arr)
Expected Output:
[1 2 3]
Unique Values
-
np.unique(arr)– Returns the sorted unique elements of an array.
arr = np.array([1, 2, 2, 3, 3, 3])
unique_vals = np.unique(arr)
Expected Output:
[1 2 3]
Stacking and Splitting
-
np.vstack()– Stacks arrays vertically. -
np.hstack()– Stacks arrays horizontally. -
np.split()– Splits arrays into multiple sub-arrays.
arr1 = np.array([1, 2])
arr2 = np.array([3, 4])
vstacked = np.vstack((arr1, arr2))
hstacked = np.hstack((arr1, arr2))
splits = np.split(np.array([1, 2, 3, 4]), 2)
Expected Output:
Vertical stack: [[1 2]
[3 4]]
Horizontal stack: [1 2 3 4]
Splits: [array([1, 2]), array([3, 4])]
Conclusion
NumPy is an essential library for any Python user working with large amounts of numerical data. With its efficient handling of arrays and vast range of mathematical operations, it lays the foundation for more advanced topics such as machine learning, data analysis, and scientific computing.
