DEV Community

Harsh Mishra
Harsh Mishra

Posted on

Numpy Cheat Sheet

Comprehensive 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
Enter fullscreen mode Exit fullscreen mode

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]]])
Enter fullscreen mode Exit fullscreen mode

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]]]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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.]]
Enter fullscreen mode Exit fullscreen mode

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 from low (inclusive) to high (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))
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Random array: [[0.234 0.983]
               [0.456 0.654]]
Random integer array: [[5 7 2]
                       [3 9 1]]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Shape: (2, 3)
Size: 6
Dimensions: 2
Data type: int32
Item size: 4
Enter fullscreen mode Exit fullscreen mode

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()
Enter fullscreen mode Exit fullscreen mode

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]]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

2
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

6
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

6
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[20 30 40]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[[40 50]
 [70 80]]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[[5 6]]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[25 30]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Appended: [1 2 3 4]
Inserted: [ 1 10 20  2  3]
Concatenated: [1 2 3 4 5]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Deleted: [1 3 4]
Slice deleted: [1 4]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Addition: [5 7 9]
Subtraction: [-3 -3 -3]
Multiplication: [ 4 10 18]
Division: [0.25 0.4 0.5]
Enter fullscreen mode Exit fullscreen mode

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))
Enter fullscreen mode Exit fullscreen mode

Expected Output:

15


3.0
3.0
1.4142135623730951
1 5
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[11 12 13]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

10. Other Useful Functions

Sorting

  • np.sort(arr) – Returns a sorted array.
arr = np.array([3, 1, 2])
sorted_arr = np.sort(arr)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[1 2 3]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

[1 2 3]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Expected Output:

Vertical stack: [[1 2]
                 [3 4]]
Horizontal stack: [1 2 3 4]
Splits: [array([1, 2]), array([3, 4])]
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)