NumPy for Beginners: A Comprehensive Introduction

NumPy (Numerical Python) is the foundational library for numerical computing in Python. It provides support for large, multi-dimensional arrays and matrices, along with a vast collection of mathematical functions to operate on them. NumPy is the backbone of the scientific Python ecosystem, serving as the core data structure for libraries like Pandas, SciPy, Scikit-learn, TensorFlow, and PyTorch .

At the heart of NumPy is the ndarray, a high-performance data structure that stores elements of the same type in contiguous memory blocks. This design makes NumPy arrays significantly faster and more memory-efficient than Python lists, which store references to scattered objects .

Why NumPy over Python lists?

NumPy's performance advantage comes from its C-based implementation. When you perform an operation on a NumPy array, the looping happens in compiled C code — not in interpreted Python — yielding speedups of 10–100× for numerical operations .

Footnotes

1. NumPy: the absolute basics for beginners - Official NumPy beginner documentation covering array creation, operations, and indexing. ↩

2. Advantages of Using NumPy Arrays Over Python Lists - Comparison of NumPy arrays vs Python lists covering speed, memory, and functionality. ↩ ↩²

Core Concepts: The ndarray

Every NumPy array is an instance of ndarray. Key attributes you should know:

• ndim — number of dimensions (axes)
• shape — tuple of integers indicating size along each axis
• size — total number of elements ($\text{size} = \prod \text{shape}_i$)
• dtype — data type of elements (e.g., int64, float64)

$\text{total\_elements} = \prod_{i=0}^{\text{ndim}-1} \text{shape}[i]$

1import numpy as np
2
3a = np.array([[1, 2, 3], [4, 5, 6]])
4print(a.ndim)    # 2
5print(a.shape)   # (2, 3)
6print(a.size)    # 6
7print(a.dtype)   # int64

Creating Arrays

NumPy provides many convenience functions for creating arrays :

1import numpy as np
2
3# From a Python list
4a = np.array([1, 2, 3, 4])               # 1D array
5b = np.array([[1, 2], [3, 4]])            # 2D array
6
7# Built-in creation functions
8zeros = np.zeros((3, 4))                  # 3×4 array of 0.0
9ones  = np.ones((2, 3))                   # 2×3 array of 1.0
10full  = np.full((2, 2), 7)                # 2×2 array of 7
11eye   = np.eye(3)                         # 3×3 identity matrix
12
13# Range-based creation
14arange = np.arange(0, 10, 2)             # [0, 2, 4, 6, 8]
15linspace = np.linspace(0, 1, 5)          # [0.0, 0.25, 0.5, 0.75, 1.0]
16
17# Random creation
18rand = np.random.rand(2, 3)              # 2×3 array, uniform [0, 1)
19randint = np.random.randint(0, 10, size=5)  # 5 random ints in [0, 10)

You can also explicitly set the dtype to control memory usage:

1a = np.array([1, 2, 3], dtype=np.float32)  # 32-bit float
2b = np.array([1, 2, 3], dtype=np.int8)     # 8-bit integer

Footnotes

1. NumPy: the absolute basics for beginners - Official NumPy beginner documentation covering array creation, operations, and indexing. ↩

Array Indexing and Slicing

NumPy extends Python's indexing syntax to support multi-dimensional access. Understanding the difference between a view and a copy is critical .

Basic indexing and slicing uses the start:stop:step syntax in each dimension:

1a = np.array([[1, 2, 3, 4],
2              [5, 6, 7, 8],
3              [9, 10, 11, 12]])
4
5# Single element
6a[0, 1]          # 2
7
8# Entire row
9a[1, :]          # array([5, 6, 7, 8])
10
11# Entire column
12a[:, 2]          # array([3, 7, 11])
13
14# Sub-array (slice)
15a[0:2, 1:3]      # array([[2, 3], [6, 7]])
16
17# Step slicing
18a[::2, ::2]      # array([[1, 3], [9, 11]])

Boolean indexing filters elements using a condition:

1a = np.array([10, 40, 80, 50, 100])
2a[a > 50]        # array([80, 100])

Fancy indexing (also called integer array indexing) lets you select arbitrary elements :

1a = np.array([10, 20, 30, 40, 50])
2indices = np.array([0, 3, 4])
3a[indices]       # array([10, 40, 50])

Footnotes

1. Basic Slicing and Advanced Indexing in NumPy - Detailed guide on slicing, boolean, and fancy indexing with view vs copy behavior. ↩

2. Indexing on ndarrays — NumPy v2.4 Manual - Official documentation on NumPy indexing including advanced and broadcast indexing. ↩

Broadcasting

Broadcasting is one of NumPy's most powerful features. It allows you to perform arithmetic operations between arrays of different shapes without explicitly replicating data .

Broadcasting rules:

1. If arrays have different numbers of dimensions, the smaller shape is left-padded with 1s.
2. If the shape along any dimension doesn't match, the dimension with size 1 is stretched.
3. If dimensions are incompatible (neither is 1), an error is raised.

$\text{Result shape}_i = \max(A_i,\; B_i) \quad \text{where}\; A_i = 1 \;\text{or}\; B_i = 1 \;\text{or}\; A_i = B_i$

1# Scalar broadcast
2data = np.array([1.0, 2.0, 3.0])
3data * 1.6       # array([1.6, 3.2, 4.8])
4
5# 2D + 1D broadcast
6a = np.array([[0.0, 10.0, 20.0, 30.0]])  # shape (1, 4)
7b = np.array([1.0, 2.0, 3.0])            # shape (3,)
8a.T + b  # shape (4, 3) — via newaxis trick
9
10# The newaxis trick
11a = np.array([0.0, 10.0, 20.0, 30.0])    # shape (4,)
12b = np.array([1.0, 2.0, 3.0])            # shape (3,)
13a[:, np.newaxis] + b                     # shape (4, 3)

Footnotes

1. Broadcasting — NumPy v2.4 Manual - Official NumPy broadcasting rules with examples and practical use cases. ↩

Mathematical and Statistical Operations

NumPy provides ufuncs for fast element-wise computation . These include:

Arithmetic operations (element-wise):

1a = np.array([20, 30, 40, 50])
2b = np.arange(4)               # [0, 1, 2, 3]
3
4a - b          # array([20, 29, 38, 47])
5b ** 2         # array([0, 1, 4, 9])
610 * np.sin(a) # element-wise trig
7a < 35         # array([True, True, False, False])

Matrix operations (not element-wise):

1A = np.array([[1, 1], [0, 1]])
2B = np.array([[2, 0], [3, 4]])
3
4A * B         # element-wise product
5A @ B         # matrix product (Python 3.5+)
6A.dot(B)      # matrix product (alternative syntax)

Aggregation along axes:

1b = np.arange(12).reshape(3, 4)
2# array([[ 0,  1,  2,  3],
3#        [ 4,  5,  6,  7],
4#        [ 8,  9, 10, 11]])
5
6b.sum(axis=0)      # sum of each column: array([12, 15, 18, 21])
7b.min(axis=1)      # min of each row:    array([0, 4, 8])
8b.cumsum(axis=1)   # cumulative sum along rows
9b.mean()           # 5.5
10b.std()            # 3.452...

Footnotes

1. NumPy quickstart — NumPy v2.4 Manual - Official quickstart covering basic operations, universal functions, and indexing. ↩

Reshaping and Array Manipulation

One of the most common tasks is reshaping — reorganizing the same data into a different shape :

1a = np.arange(12)               # shape (12,)
2b = a.reshape(3, 4)             # shape (3, 4)  — view
3c = a.reshape(2, 2, 3)          # shape (2, 2, 3) — view
4
5# Flattening
6d = b.ravel()                    # shape (12,) — view if possible
7e = b.flatten()                  # shape (12,) — always a copy
8
9# Transposing
10f = b.T                          # shape (4, 3)
11
12# Stacking arrays
13v = np.vstack([b, b])           # vertical stack: shape (6, 4)
14h = np.hstack([b, b])           # horizontal stack: shape (3, 8)

Key rule for reshaping: the total number of elements must remain the same, i.e., $\prod \text{new\_shape} = \text{original\_size}$.

Footnotes

1. NumPy: the absolute basics for beginners - Official NumPy beginner documentation covering array creation, operations, and indexing. ↩

Linear Algebra with NumPy

NumPy's linalg module provides essential linear algebra operations. These functions rely on optimized BLAS and LAPACK libraries for high performance :

1import numpy as np
2
3A = np.array([[1, 2], [3, 4]])
4B = np.array([[5, 6], [7, 8]])
5
6# Matrix multiplication
7C = A @ B                       # or np.dot(A, B)
8
9# Determinant
10det = np.linalg.det(A)          # -2.0
11
12# Inverse
13A_inv = np.linalg.inv(A)
14
15# Eigenvalues and eigenvectors
16eigenvalues, eigenvectors = np.linalg.eig(A)
17
18# Solving linear systems Ax = b
19b = np.array([1, 2])
20x = np.linalg.solve(A, b)
21
22# Singular Value Decomposition
23U, S, Vt = np.linalg.svd(A)

Footnotes

1. Linear algebra — NumPy v2.4 Manual - Official reference for NumPy linear algebra routines backed by BLAS/LAPACK. ↩

Broadcasting Dimensions — Visual Summary

Understanding how NumPy stretches dimensions is essential. Here is a step-by-step walkthrough of broadcasting a (4, 1) array with a (1, 3) array to produce a (4, 3) result: