Chapter 5 — Introduction To Numpy

NumPy (Numerical Python) is a fundamental Python library used for numerical computing. It provides the ndarray — a fast, N-dimensional array object — and many functions to perform mathematical, logical and statistical operations on arrays efficiently.

Why use NumPy?

• Speed: NumPy arrays are implemented in C and optimized for performance, so operations on arrays are much faster than equivalent Python list operations.
• Memory efficiency: Arrays store elements in contiguous memory, using less space than Python lists.
• Vectorized operations: Element-wise arithmetic, reductions and many mathematical routines work without explicit Python loops.
• Interoperability: Widely used in data science, machine learning, image processing and scientific computing.

Core concept — ndarray

An ndarray is a grid of elements of the same type, indexed by a tuple of nonnegative integers. Key attributes:

• ndarray.ndim — number of dimensions (rank).
• ndarray.shape — tuple giving the size in each dimension (rows, columns, ...).
• ndarray.size — total number of elements.
• ndarray.dtype — data type of the elements (int, float, bool, etc.).

Creating arrays

import numpy as np
a = np.array([1, 2, 3])            # 1D array
b = np.array([[1, 2], [3, 4]])     # 2D array (matrix)
c = np.zeros((2,3))                # zeros
d = np.ones(4)                     # ones
e = np.arange(0, 10, 2)            # 0,2,4,6,8
f = np.linspace(0, 1, 5)           # 5 values evenly spaced
g = np.random.rand(3,3)            # random numbers in [0,1)

Indexing and slicing

Similar to lists but supports multi-dimensional indexing. Examples:

element = b[0,1]        # first row, second column
row = b[1, :]            # second row
col = b[:, 0]            # first column
sub = b[0:2, 0:1]        # slice (rows 0..1, cols 0..0)

Vectorized operations & broadcasting

Arithmetic on arrays is element-wise:

x = np.array([1,2,3])
y = np.array([4,5,6])
print(x + y)    # [5,7,9]
print(x * 2)    # [2,4,6]
print(x * y)    # [4,10,18]

Broadcasting allows operations between arrays of different shapes when they are compatible: NumPy virtually expands the smaller array to match the shape of the larger one rather than copying data.

Common array operations

• Reshape: arr.reshape(new_shape)
• Transpose: arr.T
• Aggregation: np.sum, np.mean, np.std, np.min, np.max
• Linear algebra: np.dot (dot product / matrix multiply), np.linalg.inv, np.linalg.eig

Typical workflow

1. Create or load data into ndarrays (from lists, files or libraries like pandas).
2. Use vectorized operations and NumPy functions to compute results.
3. Use Matplotlib (or other libraries) for visualization.

Simple example: mean and standard deviation of marks

marks = np.array([78, 85, 62, 90, 74])
mean = np.mean(marks)
std = np.std(marks)
print(mean, std)

Installation: pip install numpy (or use Anaconda which includes NumPy).

NumPy is a building block for data science and scientific computing — learning it makes tasks like matrix calculations, signal processing and image handling much easier and faster than plain Python lists.

What is an ndarray?
An ndarray is NumPy's primary data structure: a homogeneous, fixed-size, N-dimensional array of items of the same data type. It stores data in contiguous memory and provides fast vectorized operations and convenient attributes to work with numeric data efficiently.

Key characteristics

• Homogeneous: every element has the same dtype (e.g., int, float).
• N-dimensional: can represent 1D (vectors), 2D (matrices/tables), 3D (images with color channels), etc.
• Attributes: shape (dimensions), ndim (number of axes), size (total elements), dtype (data type).
• Fast: vectorized operations avoid Python loops and use optimized C code.

Creating ndarrays (common methods)

import numpy as np
# from Python list
a = np.array([1, 2, 3])       # 1D
# ranges and spaced values
b = np.arange(0, 10, 2)       # [0 2 4 6 8]
c = np.linspace(0, 1, 5)      # 5 evenly spaced numbers
# special arrays
Z = np.zeros((3, 4))          # 3x4 zeros
O = np.ones((2, 2))
F = np.full((2,3), 7)         # filled with 7
# random
R = np.random.rand(3,3)       # 3x3 array of floats in [0,1)

Useful attributes and methods

• arr.shape — tuple giving size per axis (e.g., (rows, cols)).
• arr.ndim — number of dimensions (axes).
• arr.size — total number of elements (product of shape).
• arr.dtype — data type of elements.
• arr.reshape(new_shape) — view with a new shape (compatible size).
• arr.T — transpose (for 2D swaps axes).
• arr.astype(dtype) — convert type.

Indexing and slicing

• 1D: arr[i] retrieves element at index i.
• 2D: arr[i, j] selects element at row i, column j.
• Slice: arr[start:stop:step] works across axes: arr[1:4, :2].
• Boolean indexing and fancy indexing (arrays of indices) let you select elements conditionally or by positions.

Vectorized arithmetic and broadcasting

Operations on ndarrays are elementwise by default: adding, subtracting, multiplying two arrays of the same shape applies the operation element-by-element. Broadcasting lets arrays with different shapes participate when shapes are compatible. Brief rule: align shapes from the trailing dimension; dimensions are compatible if they are equal or one of them is 1.

A = np.array([1,2,3])       # shape (3,)
B = np.array([[10],[20]])    # shape (2,1)
C = A + B                    # result shape (2,3) via broadcasting

Performance note
Because ndarrays store values in contiguous memory and use compiled code for operations, they are much faster and more memory-efficient than Python lists for numeric computations.

When to use ndarray
Any time you have numeric data where vectorized calculations, matrix math, or memory efficiency matter — e.g., data analysis, image processing, scientific computing, machine learning.

Array creation routines are the NumPy functions you use to create ndarrays (NumPy arrays) with specific values, shapes and data types. They are the starting point for any numerical program because arrays store numeric data efficiently in contiguous memory and provide vectorized operations. Common routines include:

- np.array(obj, dtype=...): create an array from a Python list/tuple/sequence. Use dtype to set data type (int, float, bool, etc.).

- np.arange(start, stop, step): like Python range but returns an ndarray; useful for discrete sequences and time steps.

- np.linspace(start, stop, num): create num evenly spaced values between start and stop (inclusive). Good for plotting continuous functions.

- np.logspace(start_exp, stop_exp, num, base=10): values spaced evenly on a log scale.

- np.zeros(shape, dtype=...) and np.ones(shape, dtype=...): arrays filled with 0 or 1. Useful for initialization.

- np.empty(shape, dtype=...): allocate array without initializing entries (faster, values uninitialized).

- np.full(shape, fill_value, dtype=...): fill with a specific constant.

- np.eye(N) and np.identity(N): identity matrix (1s on diagonal, 0s elsewhere).

- np.diag(v): create a diagonal matrix from vector v or extract diagonal from matrix.

- np.fromiter(iterable, dtype, count=-1) and np.asarray(obj): build arrays from iterables or convert sequences to arrays without copying when possible.

Key attributes and concepts connected to creation routines: shape (tuple of dimension sizes), ndim (number of dimensions), dtype (type of elements), size (total elements), itemsize (bytes per element) and nbytes (total bytes = size * itemsize). Use .reshape(new_shape) to change shape without changing data order (if compatible).

Practical tips: use np.zeros or np.full for initialization, np.linspace for smooth plotting, and np.arange for step-based ranges. Prefer np.asarray when you want to avoid copying an existing array-like object; use copy() when you need an independent copy.

What is dtype?
In NumPy, every array has a data type called dtype that describes the kind of elements it holds (integers, floats, booleans, complex numbers, fixed-length strings, objects, dates, etc.) and how they are stored in memory (number of bytes, byte order).

Why dtype matters
Dtype affects memory usage, speed and numerical behavior. Choosing an appropriate dtype can save memory and avoid unexpected precision loss or overflow.

Common NumPy dtypes

• int8, int16, int32, int64 (signed integers)
• uint8, uint16, uint32, uint64 (unsigned integers)
• float16, float32, float64 (floating-point; float64 = double precision)
• complex64, complex128 (complex numbers: real + imaginary)
• bool (True/False)
• str_/unicode_ or fixed-length string types
• object (Python objects; flexible but slow and memory-heavy)
• datetime64, timedelta64 (dates and durations)

Inspecting and setting dtype
Use the .dtype attribute to inspect and dtype=... argument or astype() to set or convert types.

import numpy as np
a = np.array([1, 2, 3])         # default integer dtype (platform dependent)
print(a.dtype)                   # e.g. int64
b = np.array([1.0, 2.0], dtype=np.float32)
print(b.dtype)                   # float32
c = a.astype(np.float64)         # convert to float64

Memory and performance
Each dtype has an itemsize (bytes per element). Memory used = number_of_elements × itemsize. Smaller dtypes use less memory and often run faster (cache-friendly), but may reduce precision or range.

Integer ranges (signed/unsigned)
A signed integer with n bytes stores values from -2^{8n-1} to 2^{8n-1}-1. An unsigned integer of n bytes stores from 0 to 2^{8n}-1.

Floating point basics
Floating types store numbers as sign × mantissa × 2^{exponent-bias}. More bytes → more exponent/mantissa bits → larger range and better precision (e.g. float32 vs float64).

Type promotion and rules
When combining arrays of different dtypes, NumPy promotes to a common dtype following rules (simple examples):

• int + float → float
• int/float + complex → complex
• bool in arithmetic behaves like int (True→1, False→0)

Practical tips for Class 11 students

• Use uint8 for images (0–255). Saves memory and is standard for pixel values.
• Use float32 for large sensor datasets if float64 precision is not necessary.
• Avoid object dtype unless you need mixed Python objects — it removes NumPy speed benefits.

Example code (quick summary)

import numpy as np
img = np.zeros((100,100), dtype=np.uint8)   # black image, small memory
temps = np.array([30.2, 29.8, 31.0], dtype=np.float32)
mask = temps > 30.0                        # boolean mask
print(mask.dtype)                            # bool

Overview: In NumPy, an ndarray (N-dimensional array) stores homogeneous data in contiguous memory and exposes several attributes that describe its structure, type and memory layout. Understanding these attributes helps in debugging, optimizing performance and correctly manipulating arrays.

Primary attributes (attribute name — what it means):

• ndim — number of dimensions (rank) of the array.
• shape — tuple of array dimensions (length along each axis). For a 2×3 array shape is (2, 3).
• size — total number of elements (product of shape entries).
• dtype — data-type of the elements (e.g., int32, float64).
• itemsize — size in bytes of each element (depends on dtype).
• nbytes — total bytes consumed by the array data (equals size * itemsize).
• strides — tuple of bytes to step in each dimension when traversing the array (used to compute memory offset).
• T — shorthand for transpose (works for 2D; returns view with axes reversed for higher dims).
• flags — object describing memory layout (C_CONTIGUOUS / F_CONTIGUOUS), writeable, aligned, etc.
• base — if this array is a view, base points to the original array; otherwise None.
• flat — 1-D iterator over elements.
• real / imag — views for complex arrays components.

Important relationships and rules:

• size == product(shape) — total number of entries equals product of dimensions.
• nbytes == size * itemsize — total memory in bytes.
• Element memory offset formula: offset_in_bytes = sum(index[k] * strides[k]) (for all axes k).
• Reshape is allowed only if new_size == size (unless using copies/padding).
• Views share the same base and memory; copies have base is None and separate memory.
• Contiguity: C-order (row-major) means last index varies fastest; Fortran-order (column-major) means first index varies fastest. flags['C_CONTIGUOUS'] and flags['F_CONTIGUOUS'] indicate this.

Why these matter (practical consequences):

• Performance: contiguous arrays (proper order and strides) allow faster loops and BLAS calls. Unusual strides can slow operations.
• Memory: nbytes helps estimate memory usage; choose smaller dtypes to reduce footprint (e.g., float32 vs float64).
• Correctness: ensuring shapes match when broadcasting or reshaping avoids runtime errors.
• Views vs copies: modifying a view changes the underlying array; use copy() when isolation is needed.

Short code example (HTML-safe):

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]], dtype='int32')
# a.ndim -> 2
# a.shape -> (2, 3)
# a.size -> 6
# a.dtype -> int32
# a.itemsize -> 4
# a.nbytes -> 24
# a.strides -> (12, 4)  # bytes to step in each axis for C-order

These attributes are read-only descriptors that let you inspect and reason about array layout and type.

What are indexing and slicing?
Indexing is the way to access a single element of a NumPy array. Slicing is the technique to extract a range (subarray) from a NumPy array using a start:stop:step notation. These operations let you read, modify and extract parts of arrays efficiently.

Basic 1-D indexing
Use an integer index to get one element. Indexing is zero-based.

import numpy as np
a = np.array([10, 20, 30, 40])
val = a[2]   # val = 30

Negative indices
Negative indices count from the end: -1 is last element, -2 is second last, etc.

Basic slicing (1-D)
Syntax: arr[start:stop:step]

• start — inclusive index where slice begins (default 0)
• stop — exclusive index where slice ends (element at stop not included)
• step — stride between elements (default 1)

Important: views vs copies
Slicing returns a view (not a copy) of the original array when possible. Modifying the slice can change the original array. Use slice.copy() to force a copy.

2-D (and higher) indexing and slicing
Use comma-separated indices for each axis: arr[row, col]. For slices, provide slice for each axis: arr[r1:r2, c1:c2].

m = np.arange(1,13).reshape(3,4)
# m = [[ 1,  2,  3,  4],
#      [ 5,  6,  7,  8],
#      [ 9, 10, 11, 12]]
sub = m[0:2, 1:3]   # rows 0..1, cols 1..2 -> [[2,3],[6,7]]
col2 = m[:, 2]      # all rows, column index 2 -> [3,7,11]

Fancy indexing and boolean indexing
- Fancy (integer array) indexing: use a list/array of indices: arr[[i,j,k]] creates a new array containing those items.
- Boolean masking: pass a boolean array of same shape to select elements where mask is True: arr[arr > 5].

Ellipsis and newaxis
- ... (ellipsis) can fill missing slice dimensions: useful in high-dimensional arrays.
- np.newaxis (or None) can add a new dimension: arr[:, np.newaxis] converts 1-D to column vector.

Practical tips
- Remember stop is exclusive.
- Negative step (e.g., arr[::-1]) reverses an array.
- Use copy() when you need an independent array.
- Fancy and boolean indexing return copies, not views.

Summary (short examples)

# 1-D slicing: a[1:5:2]
# 2-D slicing: m[0:2, 1:4]
# Boolean mask: a[a % 2 == 0]
# Fancy indexing: a[[0,3,4]]

Fancy indexing (also called integer-array indexing) means using integer arrays or lists to select arbitrary elements from a NumPy array. Example: arr[[0,2,4]] picks elements at indices 0, 2 and 4. Fancy indexing can be used in 1D and ND arrays. When multiple index arrays are provided, NumPy treats them elementwise: a[[0,1],[2,3]] selects elements (0,2) and (1,3). To select the Cartesian product of rows and columns use np.ix_(rows, cols).

Boolean indexing uses a boolean array (mask) of the same shape (or broadcastable to the array shape) to select elements where the mask is True. The mask is commonly created with a condition: mask = arr > value. Using arr[mask] returns a 1D array of selected values in row-major order.

Important behaviour notes:

• Fancy indexing always returns a new array (a copy), not a view.
• Boolean indexing also returns a 1D array of the selected elements (copy).
• Slicing (e.g., arr[1:4]) typically returns a view, while fancy/boolean indexing return copies.
• Mask shapes must match the array shape or be broadcastable; integer index arrays determine the shape of the result.

Small illustrative code (NumPy):

import numpy as np
arr = np.array([10,20,30,40,50])
# Fancy indexing
arr[[0,2,4]]         # -> array([10, 30, 50])
# Boolean indexing
mask = arr > 25
arr[mask]            # -> array([30, 40, 50])

# 2D example
A = np.arange(12).reshape(3,4)
rows = [0,2]
cols = [1,3]
A[np.ix_(rows,cols)]    # selects 2x2 block using Cartesian product
A[[0,1],[2,3]]         # selects elements (0,2) and (1,3) elementwise

What is broadcasting?

Broadcasting is a set of rules NumPy follows to perform arithmetic operations on arrays of different shapes. Instead of explicitly copying data to match shapes, NumPy virtually stretches arrays with smaller dimensions so that elementwise operations can proceed efficiently.

Key rules (how broadcasting works)

• Compare shapes from the trailing (rightmost) dimensions.
• Two dimensions are compatible if they are equal or one of them is 1.
• If a dimension is 1 in one array, that array is conceptually repeated along that axis to match the other array.
• If all paired dimensions are compatible, the result shape has each dimension = max(size1, size2) for that axis.
• If any paired dimensions are incompatible (neither equal nor 1), NumPy raises a ValueError.

Why it matters

• Broadcasting enables concise, vectorized code (no Python loops).
• It is memory-efficient because values are not physically copied — repetition is virtual.
• Understanding broadcasting prevents subtle bugs (unexpected shape expansion or errors).

Common patterns

• Scalar + array: scalar is treated as an array of shape () and broadcasts to the array's shape.
• 1-D vs 2-D: a 1-D array can broadcast across rows or columns of a 2-D array if shapes align or you explicitly add an axis using np.newaxis or reshape.
• Column vector (n,1) + row vector (1,m) → result (n,m).

Tips: Use np.broadcast_to to see a broadcasted view, and np.expand_dims or [:, None] to add an axis intentionally when aligning shapes.

What are ufuncs?
Universal functions (ufuncs) in NumPy are functions that operate element-wise on ndarrays. A ufunc takes one or more arrays as input and returns an array where the function has been applied to each element. They are implemented in C, so they are fast and memory-efficient compared to Python loops.

Why use ufuncs?

• Element-wise operations: apply mathematical operations to every element of an array with a single call.
• Vectorized code: simpler, clearer and much faster than explicit Python loops.
• Broadcasting support: operate on arrays of different shapes when compatible.

Types of ufuncs

• Unary ufuncs (one input): e.g. np.sqrt, np.exp, np.log, np.sin. They map each element x to f(x).
• Binary ufuncs (two inputs): e.g. np.add, np.subtract, np.multiply, np.divide, np.maximum. They map element pairs (x,y) to g(x,y).

Common ufunc methods

• ufunc.reduce(array): combines elements using the ufunc (e.g. np.add.reduce is sum).
• ufunc.accumulate(array): cumulative application (e.g. np.add.accumulate is cumsum).
• ufunc.outer(A, B): computes the outer operation producing a matrix of pairwise results.

Example (concept)

import numpy as np
a = np.array([1, 4, 9])
# Unary ufunc
print(np.sqrt(a))      # array([1., 2., 3.])
# Binary ufunc with broadcasting
print(np.add(a, 5))    # array([ 6,  9, 14])
# Reduce
print(np.add.reduce(a))  # 14

Performance note
Because ufuncs are vectorized and implemented in compiled code, they run orders of magnitude faster than element-by-element Python loops for large arrays.

What it is
Arithmetic and vectorized operations in NumPy mean performing mathematical operations on whole arrays (vectors, matrices, tensors) at once instead of element-by-element with explicit Python loops. NumPy implements these operations in optimized C code, so they are concise and very fast.

Elementwise arithmetic
When two arrays have the same shape, operations are applied element by element. For arrays A and B of shape (n,), A + B produces an array C where C[i] = A[i] + B[i]. NumPy supports all common arithmetic operators: +, -, *, /, // (floor divide), % (modulus), ** (power).

Scalar operations
A scalar can be combined with an array: every element is operated with the scalar. Example: arr * 2 doubles every element in arr.

Broadcasting (shape compatibility)
Broadcasting allows arrays of different shapes to participate in elementwise operations when one array can be 'stretched' along dimensions of size 1. Rules (brief):

• Compare shapes from right to left.
• Dimensions are compatible if they are equal or one of them is 1.
• If compatible, the smaller array behaves as if repeated along the dimension with size 1.

Vectorized functions
NumPy and related modules provide vectorized math functions (no explicit loops): np.sin, np.cos, np.exp, np.sqrt, np.log, and aggregation/reduction functions like np.sum, np.mean, np.cumsum. These operate elementwise or reduce dimensions efficiently.

Linear-algebraic vectorized ops
Besides elementwise ops, there are vectorized linear algebra operations such as dot product (np.dot or @) and matrix multiplication. Dot product of two 1-D arrays a and b: np.dot(a,b) = sum(a[i]*b[i]).

Why use vectorized operations?

• Performance: C-level loops make operations much faster than Python loops.
• Concise code: expressions are shorter and clearer (for example, normalize data with one line).
• Less error-prone: fewer explicit loops and index manipulations.

Short code examples

import numpy as np
# elementwise operations
A = np.array([1, 2, 3])
B = np.array([10, 20, 30])
C = A + B        # array([11, 22, 33])
D = A * 2        # array([2, 4, 6])

# broadcasting (add row vector to each row of a matrix)
M = np.array([[1,2,3],[4,5,6]])   # shape (2,3)
v = np.array([10,20,30])          # shape (3,)
R = M + v                          # each row of M increased by v

# vectorized math
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)                     # compute sine for 100 points at once

# dot product
s = np.dot(A, B)                   # 1*10 + 2*20 + 3*30 = 140

# aggregation
total = np.sum(B)                  # 60

What this topic covers

Aggregation and statistical functions in NumPy provide fast ways to compute summary values from arrays: totals, averages, spread, percentiles, running sums, counts, and indices of extrema. These functions are optimized for performance and can operate along specific axes of multi-dimensional arrays.

Key concepts

• Aggregation — reducing an array to fewer values (e.g., sum, product, min, max) using functions such as np.sum, np.prod, np.min, np.max.
• Statistical — computing mean, median, variance, standard deviation, percentiles with np.mean, np.median, np.var, np.std, np.percentile.
• Axis parameter — for multi-dimensional arrays use axis=0 to aggregate down the rows (column-wise) and axis=1 to aggregate across columns (row-wise). If axis=None (default) the function reduces the entire array to a scalar.
• Indices of extrema — np.argmax and np.argmin return positions (indices) of maximum and minimum values.
• Running/cumulative — np.cumsum and np.cumprod compute cumulative sums/products.
• Missing values — many functions have NaN-safe versions like np.nansum, np.nanmean that ignore NaN values.

Behavior and important options

• dtype can be specified to control accumulator precision (e.g., sum of ints into a 64-bit int or float).
• Variance and standard deviation by default compute population values: np.var(...) uses divisor N. For sample variance use ddof=1 (divisor N - ddof).
• keepdims=True preserves reduced axes as length-1 dimensions, useful when broadcasting results back to original shape.
• np.unique(arr, return_counts=True) gives unique values and their frequencies — useful for categorical aggregation.

Small code examples (illustrative)

import numpy as np
marks = np.array([72, 85, 91, 67, 88])
np.sum(marks)            # total marks
np.mean(marks)           # average
np.median(marks)         # median
np.std(marks)            # population std dev
np.var(marks, ddof=1)    # sample variance (ddof=1)
np.percentile(marks, 75) # 75th percentile
np.argmax(marks)         # index of highest mark
np.cumsum(marks)         # running total

# 2D array example
arr = np.array([[10,20,30],[40,50,60]])
np.sum(arr, axis=0)  # column-wise sums -> [50,70,90]
np.sum(arr, axis=1)  # row-wise sums    -> [60,150]

Why use NumPy functions?

• They are vectorized and implemented in C, so they are much faster than Python loops for large datasets.
• They provide concise, readable code for common summarisation tasks used in data analysis, science and machine learning.

What is an axis? In NumPy, an axis is a direction along which elements are arranged in an array. Each dimension of an array has an axis number: axis 0 is the first dimension, axis 1 the second, and so on. A 1D array has one axis, a 2D array has two axes (rows = axis 0, columns = axis 1), a 3D array has three axes (for example depth, height, width or batch, height, width), etc.

Axis numbering and shapes: If an array has shape (d0, d1, d2, ...), then

• axis 0 has length d0, axis 1 has length d1, etc.
• Negative axis indices count from the end: axis -1 is the last axis.

Operations along axes mean the operation is applied across elements in the specified direction, typically reducing that axis (e.g., sum, mean) or combining arrays along that axis (e.g., concatenate). Common behaviors:

• Reduction functions (sum, mean, min, max, std, var, argmax, argmin, etc.) collapse the specified axis, producing an output whose shape has that axis removed (unless keepdims=True).
• keepdims=True preserves the reduced axis as a length-1 dimension (useful for broadcasting).
• Transformation functions (transpose, swapaxes, moveaxis) reorder axes without changing data values, only their interpretation.
• apply_along_axis lets you apply a Python function to 1D slices along a specified axis.

How to interpret axis in 2D (most common):

• sum(axis=0) — collapse rows: you get one result per column (summing down each column).
• sum(axis=1) — collapse columns: you get one result per row (summing across each row).

Examples of practical interpretation:

• Spreadsheet: rows = records (students), columns = features (subjects). mean(axis=1) gives each student’s average; mean(axis=0) gives class average per subject.
• Images: a grayscale image is 2D (height, width). An RGB image is 3D (height, width, channels). mean(axis=(0,1)) of an RGB image computes the average color across pixels (reduce the height and width axes, leaving channels).
• Machine learning batch: array shape (batch, features). mean(axis=0) computes feature-wise mean across the batch; mean(axis=1) gives per-sample mean.

Important functions and behaviors:

• np.sum, np.mean, np.min, np.max, np.std, np.var, np.cumsum, np.cumprod accept an axis argument.
• np.concatenate(arrays, axis=...) joins arrays along the given axis. np.stack adds a new axis.
• np.transpose or arr.T reorders axes; transpose accepts an axes tuple to specify the new order.
• np.apply_along_axis(func, axis, arr) runs func on 1D slices along axis and collects results.

What they are

Reshaping and transposing are array-manipulation operations in NumPy that change how data is viewed without changing the underlying elements (when possible).

Reshaping

Reshaping changes the shape (dimensions) of an array while keeping the same number of elements. For example, a 1D array of length 12 can be reshaped into shapes like (3,4), (4,3), (2,2,3), etc. The only requirement is that the product of the new dimensions equals the total number of elements.

arr = np.arange(12)         # shape: (12,)
arr.reshape(3, 4)           # shape: (3, 4)
arr.reshape(-1, 6)          # infer first axis -> shape: (2, 6)

Notes:

• Using -1 lets NumPy infer that dimension.
• reshape usually returns a view (no copy) when possible; otherwise it returns a copy.
• flatten() returns a copy; ravel() returns a view when possible (so ravel is generally preferred for efficiency).
• np.resize differs because it can change total size (it repeats or trims elements) and modifies in place for ndarray.resize.

Transposing

Transposing reorders axes. For 2D arrays it swaps rows and columns: a shape (m, n) becomes (n, m). For higher-dimensional arrays you can provide a permutation of axes.

mat = np.array([[1,2,3], [4,5,6]])   # shape: (2, 3)
mat.T                                  # shape: (3, 2)
np.transpose(arr, axes=(2, 0, 1))      # permute axes for 3D array

Notes:

• Transpose is very common when converting between frameworks that expect different axis orders (example: image arrays between HWC and CHW).
• transpose typically returns a view by changing strides, so it's efficient.

Memory order and copies

NumPy arrays are stored in memory with a specific order (row-major 'C' by default or column-major 'F'). Some reshape or transpose operations can be implemented by only changing shape/strides (no copy). Others require rearranging data (copy) — especially when forcing a particular memory order with order='C' or order='F'.

When to use which

• Reshape to convert flat feature vectors into matrices or image shapes for processing.
• Transpose to swap axes (rows/columns), or reorder channels/axes between libraries.
• Use ravel() when you want a flattened view without copying if possible; use flatten() when you explicitly want an independent copy.

Common pitfalls

• Trying to reshape to incompatible shape (product mismatch) raises an error.
• Assuming reshape always returns a copy — it may be a view, so modifying the result can affect the original array (and vice versa).
• Confusing axis order in images: HWC (height, width, channels) vs CHW (channels, height, width).

Short reference

• np.reshape(a, newshape, order='C')
• a.reshape(newshape)
• a.ravel(order='C') — flattened view when possible
• a.flatten(order='C') — flattened copy
• np.transpose(a, axes=None) or a.T
• a.swapaxes(i, j) — swap two axes

What it means
In NumPy, stacking combines multiple arrays into one bigger array along a chosen axis. Splitting divides an array into multiple smaller arrays along a chosen axis. These operations are fundamental when preparing, combining or partitioning datasets.

Common functions

• np.concatenate((a, b, ...), axis=...) — general join along an axis; arrays must match in all other dimensions.
• np.vstack((a, b, ...)) — vertical stack (like adding rows) — equivalent to concatenate(..., axis=0) for 2D arrays.
• np.hstack((a, b, ...)) — horizontal stack (like adding columns) — equivalent to concatenate(..., axis=1) for 2D arrays.
• np.stack((a, b, ...), axis=k) — joins arrays by creating a new axis at position k; shapes of inputs must be identical.
• np.dstack((a, b, ...)) — stacks arrays along the third axis (depth), useful to combine 2D arrays into a 3D array.
• np.column_stack((a, b, ...)) — stacks 1D arrays as columns into a 2D array.
• np.split(array, indices_or_sections, axis=...) — splits into equal pieces (if possible) or at specified indices.
• np.hsplit, np.vsplit — shortcuts to split horizontally/vertically. np.array_split allows unequal splits.

Shape rules (short)
When concatenating along axis i, all arrays must have the same shape for every axis except i. For stack, all input arrays must have identical shapes; the result gains one more axis.

Small code examples

# vertical stack (rows added)
import numpy as np
A = np.array([[1,2],[3,4]])   # shape (2,2)
B = np.array([[5,6]])         # shape (1,2)
np.vstack((A,B))              # shape (3,2)

# horizontal stack (columns added)
C = np.array([[7],[8],[9]])  # shape (3,1)
np.hstack((np.vstack((A,B)), C))  # shape (3,3)

# stack creating a new axis
X = np.array([1,2])  # shape (2,)
Y = np.array([3,4])  # shape (2,)
np.stack((X,Y), axis=0)  # shape (2,2)
np.stack((X,Y), axis=1)  # shape (2,2) but different layout

# split an array
M = np.arange(12).reshape(3,4)
np.hsplit(M, 2)    # splits into 2 arrays each with 2 columns
np.array_split(M, 4, axis=1)  # splits into 4 parts, some may be smaller

Errors to watch for
If shapes don't match along non-concatenation axes you will get a ValueError. When using np.split with an integer number of sections, the size along that axis must be divisible by the number of sections (use array_split if not).

When to use in real life

• Merging rows from multiple CSV files into one dataset (use vstack/concatenate).
• Adding new feature columns to a dataset (use hstack or column_stack).
• Combining color channels (R, G, B) into an image array (use dstack).
• Splitting data into train/validation/test sets (use array_split or manual indexing).

Summary
Stacking joins arrays (along rows, columns, depth or a new axis). Splitting cuts arrays into parts. Pick the appropriate function based on desired axis and whether inputs need identical shapes.

What they are
In NumPy an array can either be an independent copy of data or a view that shares the same underlying memory as another array. A copy stores its own data block; changing it does not affect the original. A view is a different array object that references the same data buffer as the original; changes through the view change the original and vice versa.

How views are usually created
Slicing (e.g. a[1:5]), many reshaping operations (reshape, transpose when possible), and ravel() (when it can return a view) typically produce views. Views are memory-efficient because they avoid duplicating data.

How copies are usually created
Advanced/ fancy indexing (e.g. a[[0,2,5]]), boolean indexing, np.copy(a), a.copy(), flatten(), and many arithmetic operations produce copies.

Detecting whether you have a view

• arr.base: if arr.base is not None, arr is a view (arr.base refers to the original array that owns the data).
• np.shares_memory(a, b): returns True if two arrays share memory.

Memory relation and index mapping
Every ndarray has attributes .shape, .dtype, .strides and .size. The byte offset of an element with indices (i0, i1, ...) in the underlying buffer is computed as:

offset = i0*strides[0] + i1*strides[1] + ...

This is why views with different shapes/strides (for example, a transpose) can still reference the same memory.

When to use which
Use a view when you want a lightweight window into a large dataset (memory saving and faster). Use a copy when you need an independent array (safe modification, pass to functions that modify in-place).

Common gotchas

• Assuming slicing returns a copy: slices usually return views, so modifying a slice may modify the original.
• Assuming reshape always copies: reshape returns a view iff the new shape is compatible with the same memory layout; otherwise it copies.
• flatten() always returns a copy, while ravel() returns a view when possible.

Overview: Sorting arranges elements of an array in a specified order (ascending or descending). Searching finds element(s) or index/indices that match a condition. In NumPy these operations are optimized for numeric arrays and large datasets.

Sorting in NumPy: NumPy provides several routines:

• np.sort(array) – returns a sorted copy.
• array.sort() – sorts the array in place.
• np.argsort(array) – returns indices that would sort the array (useful to reorder related arrays).
• np.lexsort((key1, key2, ...)) – sorts by multiple keys (stable, last key is primary).
• np.partition(array, k) / np.argpartition(array, k) – partially sorts so that the k-th element is in place and all smaller elements are before it (useful for selection problems like top-k).
• Sort types (kind parameter): 'quicksort', 'mergesort', 'heapsort' — choose depending on stability and performance needs; mergesort is stable.

Searching in NumPy:

• np.where(condition) – returns indices where condition is True (linear scan).
• np.nonzero(array) – indices of non-zero elements.
• np.searchsorted(sorted_array, value) – finds insertion index using binary search (array must be sorted).
• np.argmax(array) / np.argmin(array) – index of first maximum/minimum.
• Boolean indexing (e.g., arr[arr > 5]) is used to select elements matching a condition.

Complexities & behaviour:

• General sorting (Timsort/mergesort/quicksort variants): average time O(n log n).
• Linear search / condition checks (np.where, boolean indexing): O(n).
• Binary search (np.searchsorted on sorted arrays): O(log n).
• Partial selection (np.partition): expected O(n) for selection of k-th element.

Practical notes: Use argsort when you need to reorder several related arrays by the same key (e.g., names and marks). Use searchsorted for repeated membership/insertion checks on large sorted arrays. Prefer vectorized NumPy operations over Python loops for speed.

Overview: Linear algebra studies vectors and matrices and the rules for combining them. In the context of NumPy (a Python library), matrices are represented as arrays and NumPy provides fast functions for algebraic operations used in data science, image processing, physics and engineering.

Vectors and matrices: A vector is a 1-D array (e.g. [x1, x2, x3]). A matrix is a 2-D array with rows and columns. In NumPy you create them with np.array(). Matrices represent linear maps, systems of linear equations, images (pixel grids), adjacency in graphs, etc.

Basic operations:

• Addition / subtraction: element-wise; matrices must have the same shape. NumPy: A + B.
• Scalar multiplication: multiply every element by a number: c * A.
• Dot product (vectors): sum of pairwise products: np.dot(u, v) or u @ v.
• Matrix multiplication: combine rows of the left with columns of the right. NumPy: A @ B or np.matmul(A, B).
• Transpose: flip rows and columns. NumPy: A.T.
• Determinant & inverse: scalar value and matrix inverse (when determinant ≠ 0). NumPy: np.linalg.det(A), np.linalg.inv(A).
• Rank: number of independent rows/columns: np.linalg.matrix_rank(A).
• Solving linear systems: Solve Ax = b with np.linalg.solve(A, b) (stable and preferred over explicit inversion).

Key properties:

• Associativity: (A B) C = A (B C).
• Distributivity: A(B + C) = AB + AC.
• Transpose of a product: (AB)^T = B^T A^T.
• Inverse of a product: if A and B invertible, (AB)^{-1} = B^{-1} A^{-1}.
• Identity matrix I: AI = IA = A. In NumPy: np.eye(n).

NumPy tips: use vectorized operations (array arithmetic and @) instead of Python loops for speed. For stability and performance, prefer np.linalg.solve to computing inverses when solving linear systems. For large problems use specialized libraries (SciPy, BLAS/LAPACK) which NumPy calls under the hood.

File I/O (input/output) with NumPy means reading arrays from files and writing arrays to files. It is essential for saving results, loading datasets (for example CSV records of student marks or sensor logs), and exchanging data between programs. NumPy provides functions for text formats (CSV and others) and efficient binary formats (.npy, .npz).

Key ideas:

• Text I/O is human-readable (CSV, space-delimited) and interoperable but slower and may lose exact dtype information.
• Binary I/O ('.npy' and '.npz') is fast, preserves dtype and array shape, and is preferred when working only with NumPy.

Common functions and examples:

• numpy.savetxt — save 1D or 2D arrays to text files (CSV or other delimiters). Use parameters like delimiter, fmt, header, comments.
• numpy.loadtxt — load arrays from text files when data has consistent numeric types.
• numpy.genfromtxt — like loadtxt but handles missing values, mixed types and can convert columns independently.
• numpy.save — save a single array to a binary '.npy' file (fast and exact).
• numpy.savez / numpy.savez_compressed — save multiple arrays into a single '.npz' archive (uncompressed or compressed).
• numpy.load — load arrays from '.npy' or '.npz' files; when loading text files use loadtxt or genfromtxt.
• ndarray.tofile and numpy.fromfile — lower-level functions for raw binary/text. Use with caution (less portable for text, needs dtype and shape management).

Short code examples (Class 11 level):

# Save a 2D array of student marks to CSV
import numpy as np
marks = np.array([[101, 78, 85], [102, 92, 88], [103, 67, 74]])
# columns: roll, math, physics
np.savetxt('marks.csv', marks, delimiter=',', fmt='%d', header='roll,math,physics', comments='')

# Load the CSV back
data = np.loadtxt('marks.csv', delimiter=',', skiprows=1, dtype=int)
# data is a 2D array; data[:,1] gives math marks

# Save and load a binary .npy file
np.save('marks_array.npy', marks)
loaded = np.load('marks_array.npy')

# Save multiple arrays
a = np.arange(6).reshape(2,3)
b = np.array([10,20,30])
np.savez('two_arrays.npz', arr1=a, arr2=b)
z = np.load('two_arrays.npz')
# access with z['arr1'] and z['arr2']

# Using genfromtxt for missing values
# file 'temps.csv' with header 'time,temp' and some blank temps
temps = np.genfromtxt('temps.csv', delimiter=',', names=True, dtype=None, encoding='utf-8')

Tips and behaviour:

• Use savetxt/loadtxt for CSV that contain purely numeric data. For mixed datatypes or missing values prefer genfromtxt or pandas for convenience.
• Binary files (.npy/.npz) are faster and preserve dtype and shape exactly; use them when working within NumPy.
• When using savetxt, set fmt appropriately (e.g., '%d' for integers, '%.2f' for 2-decimal floats) to control output format.
• Use skiprows and usecols to ignore headers or select columns while loading.
• For large data, compressed .npz reduces disk space but increases CPU for compression/decompression.

Common errors and how to fix them:

• ValueError from loadtxt: occurs when text file has inconsistent columns or non-numeric entries — try genfromtxt or specify dtype.
• Incorrect shapes after fromfile: fromfile reads a flat array; reshape explicitly using .reshape() with correct order and size.

Overview: Performance considerations in NumPy are about writing code that runs fast and uses memory efficiently. NumPy is implemented in C and provides fast array operations, but to get the best performance you must use NumPy features (vectorization, ufuncs, broadcasting, in-place operations) and be aware of memory layout, dtype choice, and copying vs. views.

Key principles:

• Vectorize computations: Replace Python loops with NumPy array operations (ufuncs). Although both approaches may be O(n) in complexity, NumPy's C-level loops have a much smaller constant factor, giving large speedups (often 10x–100x).
• Use ufuncs and built-in routines: Functions like np.add, np.multiply, np.dot, np.linalg.inv call optimized C/Fortran code (possibly backed by BLAS/LAPACK) and are faster than manual implementations in Python.
• Avoid unnecessary copies: Many NumPy operations return views (no copy) but some create copies. Copies cost time and memory. Use np.asarray to avoid copying if you're already working with arrays and check .flags['C_CONTIGUOUS'] for memory layout.
• Prefer in-place operations: When safe, use operators like a += b to modify arrays in place and avoid allocating new arrays.
• Choose appropriate dtype: Memory and bandwidth matter. Using float32 uses half the memory of float64 and can be faster when precision is sufficient. Memory footprint = n * itemsize.
• Memory layout and alignment: C-order (row-major) contiguous arrays are faster for most NumPy operations. Non-contiguous arrays (slices, transposes) may force copies or slower access patterns.
• Pre-allocate arrays: Repeatedly growing arrays (e.g., with np.concatenate in a loop) is slow because it reallocates and copies. Use np.empty or allocate full size upfront.
• Use specialized tools for large data: For datasets larger than memory use np.memmap or out-of-core libraries; for heavy arithmetic consider numexpr, Numba, or MKL/OpenBLAS-tuned NumPy builds.

Simple code illustration:

# Slow: Python loop
import numpy as np
n = 10_000_000
x = np.arange(n)
y = np.empty(n)
for i in range(n):
    y[i] = x[i] * 2.0

# Fast: vectorized NumPy ufunc
x = np.arange(n, dtype=np.float64)
y = x * 2.0

# In-place (saves memory):
x *= 2.0  # modifies x, no new array

Memory and speed considerations:

• Memory needed (bytes) = n * itemsize. Example: 1e7 elements of float64 (8 bytes) → 80 MB.
• Time complexity examples: elementwise operations are O(n); naive matrix multiplication is O(n^3) for n x n matrices, but optimized BLAS implementations are much faster per operation.
• Views vs copies: a slice like a[::2] returns a view if possible; operations that change shape or order (transpose of non-contiguous) may create a copy.

Practical checklist for faster NumPy code:

1. Vectorize: avoid Python for-loops over array elements.
2. Use np.dot, np.matmul, np.linalg functions for linear algebra.
3. Prefer in-place operations when you do not need the original data.
4. Keep arrays contiguous when possible; call .copy(order='C') if a contiguous copy will speed repeated operations.
5. Use smaller dtype when acceptable (int32/float32).
6. Pre-allocate arrays instead of growing them.
7. Profile code (timeit, %timeit in Jupyter) to find bottlenecks.

What NumPy is and why it matters
NumPy is a Python library for efficient numerical computing. It provides the ndarray (n-dimensional array) object, vectorized operations, broadcasting, and many mathematical functions. For Class 11 Informatics Practices, focus on using NumPy to represent data (lists of numbers, images, matrices) and perform fast calculations useful in real-life problems.

Key practical strengths

• Vectorized operations: perform elementwise math on whole arrays without explicit Python loops (fast and concise).
• Broadcasting: apply operations between arrays of different shapes when compatible.
• Linear algebra and statistics: built-in functions for dot product, matrix multiplication, mean, median, std, eigenvalues, etc.
• Memory efficiency: arrays store numbers compactly and allow bulk operations.

Common applications and short examples

1. Class/test statistics
Calculate mean, median and standard deviation of student scores to analyse class performance.

import numpy as np
scores = np.array([78, 82, 91, 65, 70])
mean = np.mean(scores)
median = np.median(scores)
std = np.std(scores)

2. Time series / Finance (returns)
Compute daily returns or moving averages for stock prices using vectorized differences.

prices = np.array([100, 103, 101, 105])
returns = (prices[1:] - prices[:-1]) / prices[:-1]  # percent change
moving_avg_3 = np.convolve(prices, np.ones(3)/3, mode='valid')

3. Linear algebra / Physics
Solve simultaneous linear equations or perform matrix multiplication for systems, transformations or circuits.

A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A, b)  # solves Ax = b

# matrix multiplication
C = A @ np.array([[1, 2], [3, 4]])

4. Image processing
An image is a 2D (grayscale) or 3D (RGB) array. NumPy enables filters, masks and simple transforms.

import matplotlib.pyplot as plt
img = plt.imread('photo.jpg')       # shape (H, W, 3)
gray = img.mean(axis=2)            # convert to grayscale
blur = (gray[:-1, :-1] + gray[1:, :-1] + gray[:-1, 1:] + gray[1:, 1:]) / 4  # simple block blur
plt.imshow(gray, cmap='gray')

5. Machine learning / Data science
Feature matrices and labels are handled as arrays; predictions are vectorized: y = X @ w + b. Batch operations make training algorithms fast.

X = np.array([[1, 2], [3, 4], [5, 6]])  # feature matrix (3 samples, 2 features)
w = np.array([0.5, -0.2])
b = 1.0
predictions = X @ w + b

Why these are useful in real life
NumPy is the backbone for data analysis, scientific computing, finance modelling, image and signal processing, simulations and many machine learning tasks. Its speed and expressiveness allow students to prototype real-world solutions quickly.

Tips for students

• Prefer NumPy operations over Python loops for speed.
• Use vectorized expressions and broadcasting to keep code simple.
• Visualise results (histograms, line plots, heatmaps) to understand data before making conclusions.