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

---

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 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))

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.

The above is the detailed content of Numpy Cheat Sheet. For more information, please follow other related articles on the PHP Chinese website!