NumPy

NumPy Foundations: Comprehensive Reference Notes

NumPy (Numerical Python) is a powerful open-source Python library used for numerical computing and scientific data processing. It provides a high-performance N-dimensional array (ndarray) object along with a rich collection of mathematical functions to perform operations efficiently on large datasets.

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 for numerical computations. NumPy forms the foundation of many popular libraries such as Pandas, Matplotlib, SciPy, Scikit-learn, TensorFlow, and PyTorch.

---

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)

At the core of the NumPy library is the NDArray (N-Dimensional Array) object. Standard Python lists have significant performance bottlenecks when handling large-scale data:

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

Vectorization is the absence of any explicit looping or indexing in your Python code.

• 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

Broadcasting describes the implicit element-by-element behaviour of array operations.

• 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

To instantiate a standard array from a Python list or iterable, use np.array():

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

Zeros Array (np.zeros)

Creates an array filled entirely with 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)

Creates an array filled entirely with ones, acting similarly to np.zeros.

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

Empty Array (np.empty)

Creates an uninitialised array of a specified shape.

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

Generates sequences of numbers over a range.

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

Generates a specified number of evenly spaced values over a specified interval.

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

Modern NumPy uses a default generator object for producing random numbers.

• 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

Knowing your array properties is essential for debugging structural errors and matching dimensional shapes.

Property	Method/Attribute	Description	Example
Dimensions	a.ndim	Returns the number of axes (dimensions) of the array.	Scalar (0D): 0 Vector (1D): 1 Matrix (2D): 2 Tensor (>2D): 3+
Shape	a.shape	Returns a tuple of non-negative integers specifying elements along each axis.	2D matrix: (rows, columns) Scalar (0D): empty tuple ()
Size	a.size	Total number of elements. Always equals the product of shape elements.	Shape (2, 4) size: 8
Data Type	a.dtype	Identifies the homogeneous data type of the elements.	e.g., int64, float64

Mental Model for Multi-Dimensional Layouts: In mathematical notation, we access a 2D matrix by row index first and column index second. For higher dimensions, a helpful mental model is that the column index comes last, and the row index is second-to-last.

---

5. Indexing and Slicing

Accessing Elements

NumPy is zero-indexed. You access elements using square brackets.

• 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

You can mutate array elements in place by assigning a value directly to a targeted index.

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

Basic Slicing

Extracts sections of an array using [start:stop:step] notation.

• 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

For a two-dimensional array, the syntax is arr[row_slice, column_slice]. You separate row and column instructions with a comma:

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

This is a powerful filtering technique where elements are selected based on logical conditions.

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)

Changes the shape structure of an array without modifying its underlying data.

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

Converts a multi-dimensional array into a flat 1D array.

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

Transposes the matrix by swapping row indices with column indices.

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

Reverses the order of elements along axes.

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

Combines multiple arrays along a specified axis.

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

Stacks arrays on top of each other (vertically along axis=0).

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

Horizontal Stacking (hstack)

Stacks arrays adjacent to each other side-by-side (horizontally along axis=1).

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

Horizontal Splitting (hsplit)

Splits an array horizontally along columns.

• 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

Understanding memory management in NumPy is critical to preventing unintended mutations.

       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

Aggregations can collapse an entire array or be calculated along specific dimensions using the axis parameter.

• 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?

Vector operations in NumPy allow mathematical operations to be performed on entire arrays at once, instead of processing one element at a time using loops. This concept is known as vectorization. NumPy internally uses highly optimized C code, making these operations much faster and more efficient than traditional Python loops.

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)

Output

[11 22 33 44]

Explanation

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)

Output

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

Output

[ 90. 160. 225.]

Explanation

Each element of the first array is multiplied by the corresponding element of the second array.

---

Example 4: Vector Division

import numpy as np

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

percentage = marks / 100

print(percentage)

Output

[0.8 0.9 0.7]

---

Example 5: Scalar Operations

A scalar is a single numeric value. NumPy automatically applies the scalar to every element of the array.

import numpy as np

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

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

Output

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

Output

[ 4  9 16]

---

Example 7: Square Root

import numpy as np

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

print(np.sqrt(a))

Output

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

Output

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

Similarly, NumPy provides many mathematical functions that operate element-wise:

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

Advantages

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

---

Real-World Example

Suppose an employee receives a ₹5,000 salary increment.

import numpy as np

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

new_salary = salary + 5000

print(new_salary)

Output

[30000 35000 45000]

The increment is automatically applied to every employee.

---

11. Broadcasting

Concept of Broadcasting

Broadcasting is a powerful feature of NumPy that allows arithmetic operations between arrays of different shapes, without explicitly copying data.

Instead of creating a larger array, NumPy virtually expands the smaller array to match the larger one whenever possible.

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

---

Broadcasting Rules

NumPy compares array dimensions from right to left.

Two dimensions are compatible if:

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

Otherwise, NumPy raises a ValueError.

---

Example 1: Scalar Broadcasting

import numpy as np

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

print(a + 5)

Output

[15 25 35]

Internally, NumPy behaves as if:

[10 20 30]
+
[ 5  5  5]

Although this larger array is never actually created.

---

Example 2: Matrix + Scalar

import numpy as np

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

print(matrix + 10)

Output

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

Every element receives the value 10.

---

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)

Output

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

Internally, the row behaves as:

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)

Output

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

Internally, the column behaves as:

1 1 1
2 2 2

---

Example 5: Student Marks

Suppose every student receives 5 bonus marks in every subject.

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)

Output

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

The bonus marks are added to every row automatically.

---

Example 6: Image Brightness

import numpy as np

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

bright_image = image + 50

print(bright_image)

Output

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

Each pixel becomes brighter.

---

Example 7: Temperature Conversion

Convert Celsius temperatures into Fahrenheit.

Formula:

F = (C × 9/5) + 32

import numpy as np

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

fahrenheit = celsius * 9/5 + 32

print(fahrenheit)

Output

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

Output

ValueError: operands could not be broadcast together

Reason

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

Comparing from the right:

3 ≠ 2

Therefore, broadcasting is not possible.

---

Broadcasting Compatibility

Array Shape 1	Array Shape 2	Compatible?	Reason
(3,)	Scalar	✔	Scalar expands
(2,3)	(3,)	✔	Row vector expands
(2,3)	(2,1)	✔	Column vector expands
(4,1)	(1,5)	✔	Both dimensions can expand
(2,3)	(2,)	✘	Last dimensions differ

---

Real-World Analogy

Imagine a teacher announces:

“Everyone gets 5 grace marks.”

Instead of giving each student the marks individually, the same bonus is automatically applied to every student.

Broadcasting works in exactly the same way—NumPy automatically applies smaller arrays wherever they fit.

---

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

Students often think that Broadcasting and Vectorization are the same. In reality, they are two different concepts that work together to perform efficient mathematical operations on NumPy arrays.

Step 1: Broadcasting (Shape Compatibility)

Broadcasting is the process of making arrays with different shapes compatible for arithmetic operations.

NumPy logically expands the smaller array to match the shape of the larger array without actually copying the data into memory.

Purpose: Make the array shapes compatible.

---

Step 2: Vectorization (Element-wise Computation)

Once the shapes become compatible, NumPy performs the mathematical operation on all elements simultaneously without using explicit Python loops.

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)

Output

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

---

Step 1: Broadcasting

The shapes of the arrays are

A : (2, 3)

B : (3,)

Since the last dimensions are compatible, NumPy logically expands the second array.

Original Arrays

A

10 20 30
40 50 60

B

1 2 3

Broadcasted (Logical Expansion)

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

After broadcasting, NumPy performs the addition on all corresponding elements simultaneously.

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

Result

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

Imagine a classroom with two rows of students.

The teacher announces:

“Each student receives 5 bonus marks.”

Instead of writing the value 5 for every student individually, the same value is automatically applied to every student in each row.

• 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

Broadcasting	Vectorization
Makes arrays of different shapes compatible.	Performs operations on entire arrays without loops.
Handles shape matching.	Handles computation.
Logically expands smaller arrays.	Performs fast element-wise arithmetic.
Occurs before computation (conceptually).	Occurs after broadcasting makes shapes compatible.

---

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

Before moving to the next section, make sure to practice your NumPy skills using the interactive notebook:

NumPy Practice Exercise

Practice your skills using the interactive notebook.

💻 VS Code | 🚀 Colab | 📥 Download

Next Library: Pandas

Learn data manipulation and analysis using Pandas DataFrames and Series.