Python, NumPy, and Vectorization Cheat Sheet

1. Importing NumPy

import numpy as np

2. Vector Creation


# Create a vector of zeros

a = np.zeros(4)

Output: [0. 0. 0. 0.]



# Create a vector with random values

a = np.random.random_sample(4)

Output: [0.74228696 0.1674833  0.42629983 0.92137134]



# Create a vector with a range of values

a = np.arange(4.)

Output: [0. 1. 2. 3.]



# Create a vector manually

a = np.array([5, 4, 3, 2])

Output: [5 4 3 2]



# Check vector shape

a.shape

Output: (4,)



# Check data type

a.dtype

Output: dtype('int64')

3. Vector Indexing and Slicing


a = np.arange(10)

a = [0 1 2 3 4 5 6 7 8 9]



# Indexing

print(a[2])

Output: 2

print(a[-1])

Output: 9 (last element)



# Slicing

print(a[2:7:1])

Output: [2 3 4 5 6]

print(a[2:7:2])

Output: [2 4 6]

print(a[3:])

Output: [3 4 5 6 7 8 9]

print(a[:3])

Output: [0 1 2]

4. Vector Operations


a = np.array([1, 2, 3, 4])

a = [1 2 3 4]



# Negation

print(-a)

Output: [-1 -2 -3 -4]



# Sum of elements

print(np.sum(a))

Output: 10



# Mean of elements

print(np.mean(a))

Output: 2.5



# Element-wise squaring

print(a**2)

Output: [1 4 9 16]



# Scalar multiplication

print(5 * a)

Output: [5 10 15 20]



# Element-wise operations

b = np.array([-1, -2, 3, 4])

print(a + b)

Output: [0 0 6 8]



# Dot product

print(np.dot(a, b))

Output: 24



# Custom dot product (for-loop based)

def my_dot(a, b):

    result = 0

    for i in range(len(a)):

        result += a[i] * b[i]

    return result

print(my_dot(a, b))

Output: 24

5. Matrix Creation


# Create a 2D array

a = np.zeros((2, 3))

Output:

[[0. 0. 0.]

 [0. 0. 0.]]



# Create a matrix manually

a = np.array([[1, 2, 3],

              [4, 5, 6]])

Output:

[[1 2 3]

 [4 5 6]]



# Reshape an array

a = np.arange(6).reshape(-1, 2)

Output:

[[0 1]

 [2 3]

 [4 5]]

6. Matrix Indexing and Slicing


a = np.arange(20).reshape(-1, 10)

a =

[[ 0  1  2  3  4  5  6  7  8  9]

 [10 11 12 13 14 15 16 17 18 19]]



# Access an element

print(a[1, 2])

Output: 12



# Access a row

print(a[1])

Output: [10 11 12 13 14 15 16 17 18 19]



# Slice columns

print(a[:, 2:7:1])

Output:

[[ 2  3  4  5  6]

 [12 13 14 15 16]]



# Access all elements

print(a[:, :])

Output:

[[ 0  1  2  3  4  5  6  7  8  9]

 [10 11 12 13 14 15 16 17 18 19]]

7. Vectorization vs. Loops

Vectorized operations are much faster than loops for large arrays.
Use NumPy's built-in functions and operations when possible.
Example: np.dot(a, b) is much faster than a loop-based dot product implementation.
Example using time module for performance:


        import time

        tic = time.time()

        np.dot(a, b)

        toc = time.time()

        print(f"Time taken: {toc - tic} seconds")

8. Broadcasting

NumPy operations automatically broadcast when array shapes are compatible.
Useful for operations between arrays of different shapes.

9. Common Pitfalls

Be careful with integer division (use // for floor division).
Watch out for copy vs. view operations on arrays. Use np.copy() for independent arrays.
Be mindful of broadcasting rules to avoid unexpected results.

10. Useful NumPy Functions

np.sum(), np.mean(), np.max(), np.min()
np.reshape(), np.transpose()
np.concatenate(), np.stack()
np.where() for conditional operations

Remember to always check the shape of your arrays using array.shape to ensure your operations are valid!