rand, randn, randint & random

Most random-data jobs need one of three things: a probability-like float between 0 and 1, a bell-curve value around an average, or a whole number in a range (dice rolls, runs, ball numbers). NumPy's legacy np.random module has one function for each, plus an alias.

Definition

np.random.rand(d0, d1, ...) returns floats drawn from the uniform distribution over [0, 1) — every value between 0 (included) and 1 (excluded) is equally likely.

np.random.randn(d0, d1, ...) returns floats drawn from the standard normal distribution — a bell curve with mean 0 and standard deviation 1, so values can be negative.

np.random.randint(low, high=None, size=None) returns random integers from low (inclusive) to high (exclusive). If only one number is given, the range is 0 to that number (exclusive).

np.random.random(size) is the same as rand, but takes the shape as one tuple instead of separate numbers.

• Uniform — flat: no value is more likely than another.
• [0, 1) — the square bracket means 0 can appear, the round bracket means 1 never appears.
• Standard normal — "standard" means mean 0, std 1. About 68% of values fall between −1 and 1, and about 95% between −2 and 2.
• Exclusive high — exactly like Python's range(): randint(1, 7) gives 1–6, a perfect dice.

Syntax

np.random.rand(d0, d1, ..., dn)          # shape as separate ints
np.random.randn(d0, d1, ..., dn)         # shape as separate ints
np.random.randint(low, high=None, size=None, dtype=int)
np.random.random(size=None)              # shape as ONE tuple

Example — rand: uniform floats in [0, 1)

import numpy as np
np.random.seed(42)
print(np.random.rand())          # one float in [0, 1)
print(np.random.rand(4))         # 1D: 4 floats
print(np.random.rand(2, 3))      # 2D: 2 rows x 3 columns

0.3745401188473625
[0.95071431 0.73199394 0.59865848 0.15601864]
[[0.15599452 0.05808361 0.86617615]
 [0.60111501 0.70807258 0.02058449]]

How it works: with no arguments you get a plain Python-style float. Each extra argument adds a dimension: rand(2, 3) → shape (2, 3). Notice the shape is not a tuple here.

Example — randn: the standard bell curve

np.random.seed(42)
z = np.random.randn(6)
print(z.round(3))
print(np.random.randn(2, 2).round(3))

[ 0.497 -0.138  0.648  1.523 -0.234 -0.234]
[[ 1.579  0.767]
 [-0.469  0.543]]

Values cluster around 0 and can be negative. To get a bell curve with your own mean and spread, scale and shift: mean + std * randn(...).

np.random.seed(42)
z = np.random.randn(5)
scores = 35 + 12 * z          # shift to mean 35, stretch to std 12
print(scores.round(1))

[41.  33.3 42.8 53.3 32.2]

Example — randint: whole numbers in a range

np.random.seed(42)
print(np.random.randint(1, 7, size=10))        # dice: 1..6
print(np.random.randint(0, 120, size=(2, 4)))  # IPL scores, 2 x 4
print(np.random.randint(5))                    # one int from 0..4

[4 5 3 5 5 2 3 3 3 5]
[[ 99 103  23   2]
 [ 21  52   1  87]]
3

How it works: randint(1, 7) can return 1, 2, 3, 4, 5 or 6 — never 7. Here size is a tuple, unlike rand.

Example — random: rand with a tuple

np.random.seed(42)
print(np.random.random(3))
print(np.random.random((2, 2)))

[0.37454012 0.95071431 0.73199394]
[[0.59865848 0.15601864]
 [0.15599452 0.05808361]]

Same numbers as rand with the same seed — it is literally the same generator, only the way you pass the shape differs.

Comparison — rand vs randn vs randint vs random

Proof with 100,000 draws of each:

rand    -> min 0.0000033  max 0.9999780  mean 0.500
randn   -> min -4.6946 max 4.2859  mean 0.010  std 0.998
randint -> min 1       max 6       mean 3.497

Common mistakes

• ❌ np.random.rand((2, 3)) → TypeError. ✅ np.random.rand(2, 3) or np.random.random((2, 3)).
• ❌ np.random.randint(1, 6) for a dice — it never returns 6. ✅ randint(1, 7).
• ❌ Using randn when values must be positive (runs, prices). ✅ Use randint/uniform, or clip: np.clip(x, 0, None).
• ❌ Expecting rand to ever return exactly 1.0. ✅ The upper end is excluded.

Interview tip

Q: What is the difference between np.random.rand and np.random.randn? A: rand draws from a uniform distribution on [0, 1) — all values equally likely, never negative. randn draws from the standard normal distribution (mean 0, std 1) — values cluster near 0 and can be negative.