Run NumPy Online – Free NumPy Online Compiler

Our free online NumPy compiler provides a full scientific computing environment directly in your browser. Whether you are practicing for a data science interview or calculating complex algorithms, here is how to start:

1. Import NumPy: Begin your script with the standard import convention: import numpy as np.
2. Create Arrays: Replace slow Python lists with fast, typed multidimensional arrays using np.array([1, 2, 3]), or generate them programmatically with np.zeros((3, 3)), np.ones(10), np.arange(0, 100, 2), and np.linspace(0, 1, 50).
3. Index and Slice: Use arr[2:7], matrix[:, 0] for the first column, or boolean masks like arr[arr > 0] to pull out exactly the data you want — no copies until you ask for one.
4. Do Math, the Vectorised Way: Add, multiply, raise to powers, take sines and exponentials directly on whole arrays: 2 * arr + 1, np.exp(arr), a @ b for matrix multiplication.
5. Aggregate: Collapse arrays with arr.sum(), arr.mean(), arr.std(), arr.min(), arr.max() — and use axis=0 or axis=1 to reduce along rows or columns of a matrix.
6. Reshape Freely: arr.reshape(4, 5), arr.flatten(), arr.T for transpose, or np.stack / np.concatenate to glue arrays together along any axis.
7. Save and Load: Persist arrays with np.save("data.npy", arr) and read them back with np.load("data.npy"), or use np.savetxt / np.loadtxt for plain CSV interchange.

To explore all available mathematical functions, random number generators, and Fourier transforms, visit the official NumPy documentation.

The first time you run a vectorised NumPy expression next to its list-comprehension twin, the gap is hard to believe. NumPy is not faster because it cheats — it is faster because it stops doing the slow things Python does by default.

A Python list of a million integers is a million boxed PyObjects scattered across the heap, each carrying a type tag, a refcount, and a pointer dance to reach its value. A NumPy array is one flat, contiguous buffer of fixed-width C numbers. That single layout choice unlocks three multipliers stacked on top of each other:

• No Python interpreter in the hot loop. Operations like arr * 2 dispatch into a tight C loop — one bytecode instruction on the Python side, millions of native multiplications on the C side.
• SIMD-friendly memory. Because the bytes sit next to each other, the CPU can stream cache lines and use vector instructions (SSE/AVX/NEON) to multiply 4 or 8 numbers per cycle.
• BLAS & LAPACK. Linear algebra (@, np.dot, np.linalg.solve) hands off to libraries that have been hand-tuned by humans for decades.

Run the snippet below in the editor and watch the timings yourself — the vectorised version is often 50-100x faster on numerical workloads, and the gap widens as arrays grow.

import numpy as np
import time

# Task: square a million numbers

# Pure Python — looped, boxed, slow
data = list(range(1_000_000))
t0 = time.time()
squared = [x * x for x in data]
print(f"List comprehension: {time.time() - t0:.4f}s")

# NumPy — contiguous memory, vectorised C loop
arr = np.arange(1_000_000)
t0 = time.time()
squared = arr * arr            # the whole array, in one shot
print(f"NumPy vectorised:   {time.time() - t0:.4f}s")
# Often 50-100x faster on numerical workloads

If there is one NumPy concept worth tattooing on the back of your hand, it is broadcasting. Broadcasting is the rule that lets a (3,) array combine cleanly with a (3, 3) matrix, or a single scalar mix with a 4D tensor, without you ever writing a loop or calling tile.

The rule, in plain English: two arrays are compatible if their shapes match from the right, with size 1 or missing dimensions allowed. NumPy compares the shapes axis by axis, starting from the trailing dimension. If a pair matches, great. If one of them is 1, NumPy stretches it. If one of them is missing, NumPy prepends a 1 and stretches that. Anything else is an error.

Three concrete cases cover almost everything you will meet:

import numpy as np

# 1) 1D array + scalar — scalar stretches to match
prices = np.array([10.0, 20.0, 30.0])
with_tax = prices * 1.2          # -> [12., 24., 36.]

# 2) 2D matrix + 1D row — row broadcasts down every row
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
row_bias = np.array([10, 20, 30])  # shape (3,)
print(matrix + row_bias)
# [[11 22 33]
#  [14 25 36]
#  [17 28 39]]

# 3) 2D matrix + 1D column — reshape to (3, 1) so it broadcasts across
col_bias = np.array([100, 200, 300]).reshape(3, 1)
print(matrix + col_bias)
# [[101 102 103]
#  [204 205 206]
#  [307 308 309]]

Notice case 3: a 1D array of shape (3,) broadcasts across the rows by default. To broadcast down the columns instead, you reshape it to (3, 1) — a shape with an explicit trailing 1 that the matrix can stretch through. This is the trick behind centring features, normalising images per channel, and most attention-mechanism shapes you will ever write.

Once broadcasting clicks, you stop writing for-loops. You start writing arithmetic.

Every modern deep-learning framework is, at heart, NumPy with a few extra superpowers bolted on. PyTorch tensors mirror NumPy arrays almost line for line — torch.zeros, torch.matmul, tensor.reshape, broadcasting rules included — but add autograd and a GPU backend. JAX goes further: it is literally a NumPy clone (jax.numpy) wrapped in jit, grad, vmap, and an XLA compiler. TensorFlow’s eager mode and CuPy’s CUDA arrays follow the same playbook.

The reason this works is the Python Array API standard, the cross-library spec that NumPy 2.0 fully adopted. It pins down the names, shapes, and semantics of array operations so library authors can write code once and have it run on NumPy, CuPy, JAX, PyTorch, or any future array backend without rewrites.

The practical takeaway: the time you spend mastering reshape, broadcasting, fancy indexing, and einsum here is not a stepping stone you throw away when you move to a GPU framework. It is the framework. Learn NumPy in the browser today and you are 80% of the way to PyTorch and JAX tomorrow.