NumPy

• 1. Introduction
• 2. NumPy Fundamentals
• 3. Creating Arrays
• 4. Array Properties
• 5. Indexing and Slicing
• 6. Array Manipulation
• 7. Combining and Splitting Arrays
• 8. Sorting and Copying
• 9. Aggregate Functions
• 10. Mathematical Vector Operations
• 11. Broadcasting
• 12. Broadcasting and Vectorization - How They Work Together
• Practice and Next Steps

​

Numpy: Numerical Python

• What is NumPy: A powerful open-source Python library used for numerical computing and scientific data processing.
• Core Object (ndarray): Provides a high-performance N-dimensional array object along with a rich collection of mathematical functions to perform operations efficiently on large datasets.
• Memory & Speed: Unlike Python lists, NumPy arrays are stored in contiguous memory and contain elements of the same data type, making them significantly faster and more memory-efficient.
• Ecosystem Foundation: Forms the foundation of many popular data science and machine learning libraries such as Pandas, Matplotlib, SciPy, Scikit-learn, TensorFlow, and PyTorch.

​

1. Introduction

​

Approach for Learning NumPy

• Concepts over Syntax: Focus on structural operations and array transformations; rely on official documentation for specific API signatures.
• Interactive Experimentation: Run code side-by-side in a notebook or REPL to inspect array shapes, dimensions, and data types in real time.
• Project-Driven Workflows: Solidify patterns and vectorization habits by building end-to-end data pipelines.

​

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. Python Lists vs. NumPy Arrays (Memory & Speed)

• Python Lists (Scattered Pointers): A list can hold mixed data types ([1, "hello", 3.14]). Because of this flexibility, each element is an independent object scattered across memory, and Python has to check each item’s type during loops.
  Python List:   [ Pointer ] ──► [ 10 ]
                 [ Pointer ] ──► [ 20 ]   (Scattered in RAM, requires slow loops)
  
• NumPy Arrays (Tightly Packed Block): An array is homogeneous—every element shares the exact same data type (e.g., all integers). All values are stored side-by-side in one continuous block of RAM.
  NumPy Array:   [ 10 | 20 | 30 | 40 ]    (Contiguous block in RAM, blazing fast)
  

​

2. Key Advantages

1. Memory Efficiency: No overhead from object wrappers or scattered pointers.
2. Blistering C-Speed: Built on precompiled C code under the hood—loops run at hardware speed without Python interpreter overhead.
3. Best of Both Worlds: You write simple, clean Python code while getting near C-level performance.

​

Element-by-Element (Element-Wise) Operations

• NumPy Arrays vs. Standard Python Lists:
  • In standard Python, + on lists concatenates them: [1, 2] + [3, 4] $\rightarrow$ [1, 2, 3, 4].
  • In NumPy, arithmetic operations perform element-by-element calculation across corresponding positions.

import numpy as np

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

# Element-wise multiplication: [1*10, 2*20, 3*30]
print(a * b)  # Output: [10 40 90]

​

Vectorization

• How it works: You write concise mathematical syntax (e.g., C = A * B), and NumPy pushes the loop execution down to precompiled, highly optimized C routines at hardware speed.

import numpy as np

# Traditional Python approach: [x * 2 for x in [1, 2, 3, 4]] (slow)
# NumPy Vectorized approach (clean, fast):
arr = np.array([1, 2, 3, 4])
print(arr * 2)  # Output: [2 4 6 8]

​

Overview of Broadcasting

​

How the Smaller Array Expands (Intermediate Step):

1. Scalar to 1D Array Expansion: A single number stretches across every position of the array:
   Original Array:  [ 10,  20,  30 ]
   Scalar:          5  ──(expands)──►  [  5,   5,   5 ]
   -----------------------------------------------------
   Result (+):      [10+5, 20+5, 30+5] = [ 15,  25,  35 ]
   
2. 1D Row Vector to 2D Matrix Expansion: A single row stretches downward to duplicate itself for every row in the matrix:
   Matrix (2x2):      Row Vector (1x2):
   [[10, 20],         [1, 2]
    [30, 40]]           │
                        ▼ (expands downward to match 2 rows)
                      [[1, 2],
                       [1, 2]]
   -----------------------------------------------------
   Result (+):        [[10+1, 20+2],   =  [[11, 22],
                       [30+1, 40+2]]       [31, 42]]
   

import numpy as np

# 1. Array + Scalar
a = np.array([10, 20, 30])
print(a + 5)  # Output: [15 25 35]

# 2. 2D Matrix + 1D Row Vector
matrix = np.array([[10, 20], 
                   [30, 40]])
row = np.array([1, 2])

print(matrix + row)
# Output:
# [[11 22]
#  [31 42]]

Note: Under the hood, this expansion is virtual—NumPy performs the calculation directly without creating extra copies in memory.

​

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

• Definition: A feature in NumPy that allows arithmetic operations between arrays of different shapes without manually reshaping them or copying data.
• How it works: NumPy automatically takes the smaller array (or scalar) and expands its dimensions to match the larger array.

​

How Shapes Expand to Match (Broadcasting Rules)

1. Right-to-Left Alignment: NumPy aligns array shapes starting from the trailing (rightmost) dimensions.
2. Dimension Expansion: Any dimension of size 1 (or a scalar) is stretched/duplicated along that axis to match the larger dimension.
3. Compatibility: If two dimensions are unequal and neither is 1, NumPy cannot expand them and raises a ValueError.

​

Example 1: Scalar Expansion (0D $\rightarrow$ 1D)

import numpy as np

a = np.array([10, 20, 30])  # Shape: (3,)

print(a + 5)

[15 25 35]

Original Array:    [ 10,  20,  30 ]
Scalar 5 expands:  [  5,   5,   5 ]  (Stretches across all 3 elements)
-----------------------------------
Result (+):        [ 15,  25,  35 ]

​

Example 2: Scalar to Matrix Expansion (0D $\rightarrow$ 2D)

import numpy as np

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

print(matrix + 10)

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

Matrix (2x3):            Scalar 10 expands to (2x3):
[[1, 2, 3],       +      [[10, 10, 10],
 [4, 5, 6]]               [10, 10, 10]]
----------------------------------------------------
Result:                  [[11, 12, 13],
                          [14, 15, 16]]

​

Example 3: Row Vector Expansion (1x3 $\rightarrow$ 2x3)

import numpy as np

matrix = np.array([[10, 20, 30],
                   [40, 50, 60]])  # Shape: (2, 3)

row = np.array([1, 2, 3])          # Shape: (3,) -> (1, 3)

print(matrix + row)

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

Matrix (2x3):            Row (1x3) expands downward (copied for each row):
[[10, 20, 30],    +      [[1, 2, 3],
 [40, 50, 60]]            [1, 2, 3]]
----------------------------------------------------
Result:                  [[10+1, 20+2, 30+3],
                          [40+1, 50+2, 60+3]]
                       = [[11, 22, 33],
                          [41, 52, 63]]

​

Example 4: Column Vector Expansion (2x1 $\rightarrow$ 2x3)

import numpy as np

matrix = np.array([[10, 20, 30],
                   [40, 50, 60]])  # Shape: (2, 3)

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

print(matrix + column)

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

Matrix (2x3):            Column (2x1) expands sideways across columns:
[[10, 20, 30],    +      [[1, 1, 1],
 [40, 50, 60]]            [2, 2, 2]]
----------------------------------------------------
Result:                  [[10+1, 20+1, 30+1],
                          [40+2, 50+2, 60+2]]
                       = [[11, 21, 31],
                          [42, 52, 62]]

​

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

• Key Concept: Students often think Broadcasting and Vectorization are identical. In reality, they are two distinct operations working in tandem.
• Step 1: Broadcasting (Shape Compatibility):
  • Mechanism: Makes arrays of different shapes compatible by logically expanding the smaller array.
  • Efficiency: No actual data duplication or copying occurs in memory.
  • Purpose: Resolves shape mismatches to enable operations.
• Step 2: Vectorization (Element-wise Computation):
  • Mechanism: Executes operations on all elements simultaneously.
  • Efficiency: Offloads iterations from interpreted Python loops to optimized precompiled C code.
  • Purpose: Performs high-speed computation once array shapes are aligned.

​

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