NumPy

​

1. Introduction

​

Approach for Learning NumPy

• Focus on Capabilities over Memorisation: Avoid attempting to mug up or memorise specific syntaxes. Instead, understand what operations and structures are supported, and refer to the official documentation when writing code.
• Active Parallel Coding: Rather than passive watching, open tutorials and official documentation side-by-side with your environment. Write the code yourself to build confidence and muscle memory.
• Project-Driven Learning: The best way to internalise syntaxes is to work on end-to-end, hands-on projects where you write the same NumPy commands repeatedly.

​

Installing and Running NumPy

• Installation: In your terminal or a Jupyter notebook cell, install the package using pip:
  pip install numpy
  
• Importing: It is standard practice to import NumPy under the alias np to keep code clean and standardised:
  import numpy as np
  
• Interactive Environments: Using interactive environments like Jupyter notebooks allows you to execute blocks of code on-the-fly and check array shapes and dimensions immediately.

​

2. NumPy Fundamentals

​

Why NumPy Arrays? (Need and Internals)

1. Homogeneity vs. Heterogeneity: Standard Python lists can contain heterogeneous data types, while NDArrays are homogeneous—all elements must share the exact same data type (e.g., all integers, all floats, or all strings).
2. The Cost of Looping in Python: For large-scale math on millions of elements, Python lists require explicit, interpreted loops. This incurs heavy overhead because Python continually interprets the code and manipulates individual Python objects in memory.
3. The C-Speed Under the Hood: NumPy operations are executed speedily at near-C speed. This is because NumPy relies on optimized, precompiled C code under the hood, saving the interpreter’s overhead and managing elements in contiguous memory blocks. It gives you the “best of both worlds”: the code simplicity of Python and the execution speed of C.

​

Vectorization

• Instead of looping over elements manually (for x in array), you write standard mathematical notations (e.g., C = A * B).
• It produces concise, highly readable, and pythonic code with fewer lines and fewer bugs.
• Looping is implicitly offloaded to precompiled C code, making operations incredibly efficient.

​

Overview of Broadcasting

• By default, when an NDArray is involved, operations (arithmetic, logical, bitwise, or functional) happen element-wise.
• If you operate on two arrays of different shapes, NumPy evaluates if their dimensions are compatible.
• If they are compatible, NumPy expands the smaller array under the hood (without making actual copies in memory) until its shape matches the larger array, allowing the element-wise operation to proceed unambiguously. If they are incompatible, a ValueError is raised.

​

3. Creating Arrays

​

Basic Array Creation

# Creating a 1D Array (Vector)
a = np.array([1, 2, 3])
print(a)  # Output: [1 2 3]

​

Zeros Array (np.zeros)

• Usage: Pass the desired shape as a single integer or a tuple.
• Note: Do not pass multiple dimensions as flat arguments (e.g., np.zeros(2, 3)), as NumPy will attempt to interpret the second argument as a data type. Always wrap multi-dimensional shapes in an outer tuple.

# 1D array of zeros
zeros_1d = np.zeros(3)  # Output: [0. 0. 0.]

# 2D array of zeros (2 rows, 3 columns)
zeros_2d = np.zeros((2, 3)) 

​

Ones Array (np.ones)

# 3D array of ones (6 blocks, 3 rows, 4 columns)
ones_3d = np.ones((6, 3, 4))

​

Empty Array (np.empty)

• How it works: Instead of setting elements to zero or one, np.empty simply allocates the memory block and leaves whatever garbage values were already present in those memory addresses.
• Why use it: It is faster than np.zeros, np.ones, or np.random because it avoids the overhead of value initialisation. It is highly useful when you plan to immediately overwrite every element in the array anyway.

# Allocating a 3x8 uninitialised array
empty_arr = np.empty((3, 8))

​

Range Creation (np.arange)

• Syntax: np.arange([start], stop, [step])
• Default values: start defaults to 0, and step defaults to 1.
• Inclusivity: The stop value is not inclusive.

# Single argument: Treated as 'stop' (creates 0 to 5)
a = np.arange(6)  # [0, 1, 2, 3, 4, 5]

# Three arguments: start, stop, step
b = np.arange(2, 10, 2)  # [2, 4, 6, 8]  (10 is not included)

# Supports floating-point step values
c = np.arange(2, 4, 0.5)  # [2.0, 2.5, 3.0, 3.5]

​

Linearly Spaced Arrays (np.linspace)

• Key Difference from arange: Instead of specifying a step size, you specify the exact number of elements you want.
• Defaults: Returns elements as float64 by default. You can explicitly override this using the dtype parameter.

# Generate 5 equally spaced values between 1 and 10
linspace_arr = np.linspace(1, 10, 5)  # [1. 3.25 5.5  7.75 10.]

# Generate spaced values as integers
linspace_int = np.linspace(1, 10, 5, dtype=np.int64)

​

Random Number Generation (np.random)

• To use it, instantiate the generator first using np.random.default_rng().
• Generate random integers within a range using the .integers(low, high, size) method.

# Initialise the default random number generator
rng = np.random.default_rng()

# Generate a 3x2 array of random integers between 2 (inclusive) and 9 (exclusive)
random_ints = rng.integers(2, 9, size=(3, 2))

​

4. Array Properties

​

5. Indexing and Slicing

​

Accessing Elements

• Positive Indexing: a[0] accesses the first element.
• Negative Indexing: a[-1] accesses the last element, and a[-2] accesses the second-to-last element.

​

Modifying Elements

a = np.array([10, 20, 30, 40])
a[3] = 13  # Modifies index 3 to 13
# Array is now: [10, 20, 30, 13]

​

Basic Slicing

• Slices include the start index but exclude the stop index.

arr = np.array([12, 89, 45, 67, 23])

# Slice up to (excluding) index 2
print(arr[:2])  # Output: [12 89]

# Slice from index 3 to the end
print(arr[3:])  # Output: [67 23]

# Slice excluding the last two elements
print(arr[:-2])  # Output: [12 89 45]

​

2D Array Slicing

matrix = np.array([
    [10, 11, 12, 13],
    [20, 21, 22, 23],
    [30, 31, 32, 33],
    [40, 41, 42, 43]
])

# 1. Slice a specific row (e.g., Row 1)
print(matrix[1, :])  # Output: [20 21 22 23]

# 2. Slice a specific column (e.g., Column 2)
print(matrix[:, 2])  # Output: [12 22 32 42]

# 3. Extract a sub-grid/block (e.g., middle 2x2 section)
# Rows 1 & 2 (indices 1:3), Columns 1 & 2 (indices 1:3)
print(matrix[1:3, 1:3])
# Output:
# [[21 22]
#  [31 32]]

# 4. Extract rows 0 to 2, but only the last column
print(matrix[0:3, -1])  # Output: [13 23 33]

# 5. Extract elements using stepping (e.g., every second row and column)
print(matrix[::2, ::2])
# Output:
# [[10 12]
#  [30 32]]

​

Conditional (Boolean) Slicing

1. Generating a Boolean Mask: Running an operator like a < 6 returns an array of True/False flags corresponding to whether each element meets the condition.
2. Filtering: Passing this mask back into the array returns a flat, new array containing only the elements where the mask is True.

a = np.array([3, 75, 6, 84, 2])

# Create a condition mask
mask = a < 7  # [True, False, True, False, True]

# Filter values
filtered_values = a[mask]  # Output: [3, 6, 2]

• Multiple Conditions: You can combine multiple logical conditions. You must wrap each condition in round brackets and use bitwise operators (& for AND, | for OR).

# Select values less than 7 OR greater than 74
filtered_multi = a[(a < 7) | (a > 74)]  # Output: [3, 75, 6, 84, 2]

• Retrieving Indices of Matches (np.nonzero): If you want to find the indices where the condition is met instead of the values themselves, use np.nonzero(condition). It returns a tuple of arrays (one for each dimension) containing coordinates of matching elements.

​

6. Array Manipulation

​

Reshaping Arrays (reshape)

• Sizing Constraint: The total size (number of elements) in the reshaped array must exactly match the original array size, otherwise NumPy throws a ValueError.

a = np.arange(6)  # Size = 6. Elements: [0, 1, 2, 3, 4, 5]

# Reshaping to 3 rows, 2 columns
reshaped_3x2 = a.reshape(3, 2)

• Row-Major vs. Column-Major Order (order): You can control how elements are read/placed in memory during a reshape:
  • order='C' (default, C-like order): Fills elements row-by-row.
  • order='F' (Fortran-like order): Fills elements column-by-column.

# If you reshape a 3x2 array to a 2x3 using different orders:
arr = np.array([[0, 1], [2, 3], [4, 5]])

print(np.reshape(arr, (2, 3), order='C'))  
# Output: [[0 1 2]
#          [3 4 5]]

print(np.reshape(arr, (2, 3), order='F'))  
# Output: [[0 2 4]
#          [1 3 5]]  (Read down columns first)

​

Flattening Arrays (flatten, ravel)

• ravel (Shallow/View): Returns a flattened view of the original array. Changes made to the ravelled array will directly mutate the original parent array. It is highly memory-efficient because no copy of the underlying data is made.
• flatten (Deep Copy): Returns a completely new 1D copy of the array. Modifying the flattened array will not affect the parent array.

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

# Ravel modification:
rav = parent.ravel()
rav[0] = 99
print(parent[0, 0])  # Output: 99 (Parent array modified!)

# Flatten modification:
flat = parent.flatten()
flat[1] = 88
print(parent[0, 1])  # Output: 2 (Parent array remains unchanged!)

​

Transposing Arrays (transpose, .T)

• Access via .T or the .transpose() method.
• Transposing twice returns the original array structure. It does not modify the original parent array in place.

​

Reversing/Flipping Arrays (flip, slicing)

• np.flip(arr): Flips the elements across all axes.
• Axis-Specific Flipping:
  • np.flip(arr, axis=0) reverses vertically along the rows.
  • np.flip(arr, axis=1) reverses horizontally along the columns.
• Sub-array Flipping: You can flip targeted portions. For example, np.flip(arr[1]) reverses only the second row, while np.flip(arr[:, 1]) reverses only the second column.

​

7. Combining and Splitting Arrays

​

Concatenation (concatenate)

• By default, axis=0 is used, which vertically stacks them.
• Constraint: All arrays must have matching dimensions except along the concatenation axis, or NumPy will raise an error.

# Vertically concatenating two compatible arrays
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6]])
z = np.concatenate((x, y), axis=0)

​

Vertical Stacking (vstack)

v_stacked = np.vstack((a, b))

​

Horizontal Stacking (hstack)

h_stacked = np.hstack((a, b))

​

Horizontal Splitting (hsplit)

• Split into Equal Sections: Pass an integer specifying the number of equal sub-arrays.
• Split at Specific Coordinates: Pass a list of column indices where cuts should happen.

# x is an array with 12 columns
# 1. Split into 3 equal arrays:
part1, part2, part3 = np.hsplit(x, 3)

# 2. Split at specific column boundaries (e.g., after columns 3 and 4):
split_a, split_b, split_c = np.hsplit(x, [3, 4])

​

8. Sorting and Copying

​

Sorting Arrays (sort, argsort, partition)

• np.sort: Returns a sorted copy of the array.
• np.argsort: Returns the indices that would sort the array, allowing you to perform indirect sorting.
  arr = np.array([30, 10, 20])
  indices = np.argsort(arr)  # Output: [1, 2, 0]
  # 10 is at index 1 (smallest), 20 is at index 2, 30 is at index 0 (largest)
  
• np.partition: Partitions an array around a specified index k. All elements smaller than the element at k are shuffled to the left, and all larger elements are moved to the right. The elements on either side are not guaranteed to be sorted. This is highly useful for top-k selection algorithms.
  a = np.array([98, 90, 23, 12, 43])
  # Partition at index 3
  partitioned = np.partition(a, 3) 
  # Elements before partition index 3 are smaller than the element at 3
  

​

Views vs. Copies

       Original Array in Memory
             /          \
            /            \
    View (Shallow Copy)   Deep Copy (.copy())
    - Created by slicing  - Created via .copy()
      or indexing          - Allocates separate memory
    - Points to SAME      - Modifying does NOT
      memory                affect original
    - Modifying changes
      original

• Views (Shallow Copies): To save memory and execution overhead, basic operations like slicing and indexing return views rather than copies. If you modify a slice, the changes propagate to the original array.
• Deep Copies: If you need a completely isolated array, call the .copy() method explicitly to allocate separate memory.

​

9. Aggregate Functions

• axis=0 (Rows Axis): Computes operations vertically down columns.
• axis=1 (Columns Axis): Computes operations horizontally across rows.

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

# Sum
print(a.sum())          # 45 (sum of entire matrix)
print(a.sum(axis=0))    # [12, 15, 18] (sum down each column: 1+4+7, 2+5+8, etc.)
print(a.sum(axis=1))    # [6, 15, 24] (sum across each row: 1+2+3, 4+5+6, etc.)

# Minimum / Maximum
print(a.min(axis=1))    # [1, 4, 7] (minimum value of each row)
print(a.max(axis=0))    # [7, 8, 9] (maximum value of each column)

# Product
print(a.prod(axis=0))   # [28, 80, 162] (product down each column: 1*4*7, 2*5*8, etc.)

# Mean
print(a.mean(axis=1))   # [2., 5., 8.] (mean value of each row)

# Standard Deviation
print(a.std())          # Computes standard deviation across the entire array

​

10. Mathematical Vector Operations

​

What are Vector Operations?

Key Idea: Perform operations on the whole array with a single statement.

​

Example 1: Vector Addition

import numpy as np

a = np.array([10, 20, 30, 40])
b = np.array([1, 2, 3, 4])

result = a + b

print(result)

[11 22 33 44]

10 + 1 = 11
20 + 2 = 22
30 + 3 = 33
40 + 4 = 44

​

Example 2: Vector Subtraction

import numpy as np

a = np.array([20, 40, 60])
b = np.array([5, 10, 15])

print(a - b)

[15 30 45]

​

Example 3: Vector Multiplication

import numpy as np

prices = np.array([100, 200, 300])
discount = np.array([0.9, 0.8, 0.75])

final_price = prices * discount

print(final_price)

[ 90. 160. 225.]

​

Example 4: Vector Division

import numpy as np

marks = np.array([80, 90, 70])

percentage = marks / 100

print(percentage)

[0.8 0.9 0.7]

​

Example 5: Scalar Operations

import numpy as np

a = np.array([10, 20, 30])

print(a + 5)
print(a * 2)
print(a / 10)

[15 25 35]
[20 40 60]
[1. 2. 3.]

​

Example 6: Power Operation

import numpy as np

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

print(a ** 2)

[ 4  9 16]

​

Example 7: Square Root

import numpy as np

a = np.array([1, 4, 9, 16])

print(np.sqrt(a))

[1. 2. 3. 4.]

​

Example 8: Trigonometric Functions

import numpy as np

angles = np.array([0, np.pi/2, np.pi])

print(np.sin(angles))
print(np.cos(angles))

[0. 1. 0.]
[ 1.  0. -1.]

# Other element-wise math functions
# np.tan()
# np.log()
# np.exp()
# np.abs()

​

Why Vectorization?

​

Without NumPy

numbers = [10, 20, 30, 40]

result = []

for num in numbers:
    result.append(num + 5)

print(result)

​

Using NumPy

import numpy as np

numbers = np.array([10, 20, 30, 40])

result = numbers + 5

print(result)

• No explicit loops
• Less code
• Faster execution
• Better readability
• Optimized memory usage

​

Real-World Example

import numpy as np

salary = np.array([25000, 30000, 40000])

new_salary = salary + 5000

print(new_salary)

[30000 35000 45000]

​

11. Broadcasting

​

Concept of Broadcasting

Key Idea: Automatically expand smaller arrays so mathematical operations become possible.

​

Broadcasting Rules

• They are equal.
• One of them is 1.

​

Example 1: Scalar Broadcasting

import numpy as np

a = np.array([10, 20, 30])

print(a + 5)

[15 25 35]

[10 20 30]
+
[ 5  5  5]

​

Example 2: Matrix + Scalar

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])

print(matrix + 10)

[[11 12 13]
 [14 15 16]]

​

Example 3: Broadcasting a Row Vector

import numpy as np

matrix = np.array([[10, 20, 30],
                   [40, 50, 60]])

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

print(matrix + row)

[[11 22 33]
 [41 52 63]]

1 2 3
1 2 3

​

Example 4: Broadcasting a Column Vector

import numpy as np

matrix = np.array([[10, 20, 30],
                   [40, 50, 60]])

column = np.array([[1],
                   [2]])

print(matrix + column)

[[11 21 31]
 [42 52 62]]

1 1 1
2 2 2

​

Example 5: Student Marks

import numpy as np

marks = np.array([[75, 80, 85],
                  [65, 70, 75],
                  [90, 95, 100]])

bonus = np.array([5, 5, 5])

print(marks + bonus)

[[ 80  85  90]
 [ 70  75  80]
 [ 95 100 105]]

​

Example 6: Image Brightness

import numpy as np

image = np.array([[100, 120, 140],
                  [80, 90, 110]])

bright_image = image + 50

print(bright_image)

[[150 170 190]
 [130 140 160]]

​

Example 7: Temperature Conversion

F = (C × 9/5) + 32

import numpy as np

celsius = np.array([0, 20, 30, 40])

fahrenheit = celsius * 9/5 + 32

print(fahrenheit)

[ 32.  68.  86. 104.]

​

Example 8: Broadcasting Failure

import numpy as np

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

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

print(a + b)

ValueError: operands could not be broadcast together

Shape of a : (2, 3)
Shape of b : (2,)

3 ≠ 2

​

Broadcasting Compatibility

​

Real-World Analogy

“Everyone gets 5 grace marks.”

​

Key Points

• Broadcasting enables operations on arrays of different shapes.
• Smaller arrays are virtually expanded without copying data.
• Shapes must satisfy broadcasting rules.
• Broadcasting improves both memory efficiency and performance.
• It is one of NumPy’s most powerful features for scientific computing and machine learning.

​

12. Broadcasting and Vectorization - How They Work Together

​

Step 1: Broadcasting (Shape Compatibility)

Purpose: Make the array shapes compatible.

​

Step 2: Vectorization (Element-wise Computation)

Purpose: Perform fast element-wise operations.

​

Example

import numpy as np

A = np.array([[10, 20, 30],
              [40, 50, 60]])

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

C = A + B

print(C)

[[11 22 33]
 [41 52 63]]

​

Step 1: Broadcasting

A : (2, 3)

B : (3,)

Original Arrays

A

10 20 30
40 50 60

B

1 2 3

10 20 30
40 50 60

+

1 2 3
1 2 3

Important: NumPy does not actually create this expanded array in memory. This is only a conceptual view to understand broadcasting.

​

Step 2: Vectorization

10 + 1 = 11
20 + 2 = 22
30 + 3 = 33
40 + 1 = 41
50 + 2 = 52
60 + 3 = 63

11 22 33
41 52 63

​

Visual Representation

                 Original Arrays

             A                     B

        10 20 30               1 2 3
        40 50 60

                    │
                    ▼

       Step 1: Broadcasting
 (Logical Expansion of Smaller Array)

        10 20 30
        40 50 60

        +
        1  2  3
        1  2  3

                    │
                    ▼

       Step 2: Vectorization
 (Element-wise Arithmetic Operation)

        11 22 33
        41 52 63

​

Real-World Analogy

“Each student receives 5 bonus marks.”

• Broadcasting is like extending the single bonus value wherever it is needed.
• Vectorization is like adding those bonus marks to every student’s score simultaneously.

​

Broadcasting vs Vectorization

​

Key Takeaways

• Broadcasting and Vectorization are not the same.
• Broadcasting prepares arrays by making their shapes compatible.
• Vectorization performs the mathematical operation on the compatible arrays.
• Broadcasting does not create extra copies of the data; the expansion is only logical.
• Together, broadcasting and vectorization make NumPy fast, memory-efficient, and ideal for scientific computing, data analysis, and machine learning.

Easy to Remember:
Broadcasting prepares the arrays → Vectorization performs the computation.

​

Practice and Next Steps