Array creation — np.zeros, np.ones, np.linspace, np.arange, np.random: Visual walkthrough

Shorthand check

a

= start,

b

= stop,

s

= step,

n u m

= number of points.

Step 1 — A row of dots and the gaps between them

WHAT. Draw a straight line. Put down some evenly spaced dots. These dots are the numbers an array will hold; the line is the number line (a ruler), and the position of a dot is its value.

WHY. Before any formula, we need one physical fact clear in the eye: dots and gaps are different things, and you always have one more dot than gap. This single fact is the whole reason linspace divides by num-1.

PICTURE. Look at the figure. There are 5 orange dots but only 4 violet gaps between them. Count them yourself: put a finger on each dot, then on each space. Dots win by one — always.

Figure — Array creation — np.zeros, np.ones, np.linspace, np.arange, np.random

Fencepost check

If you see 5 posts, you have 4 rails between them.

Step 2 — What does "evenly spaced" force on us?

WHAT. We demand that every gap has the same width. Call that width $Δ$ (the Greek letter delta, which just means "a difference" — here, the difference between one dot and the next).

WHY. "Evenly spaced" is exactly the promise np.linspace makes. If gaps were allowed to differ, there would be no single formula — so we pin them all to one shared value $Δ$ .

PICTURE. Every violet gap in the figure is stamped with the same label $Δ$ . Walking from the left dot, each step to the right adds one more $Δ$ .

Because each step adds one $Δ$ , the value of the $k$ -th dot is the starting value plus $k$ copies of $Δ$ :

$x_{k} = start value a + how many steps taken k \cdot width of one step Δ, k = 0, 1, 2, \dots$

$a$ — where dot number $0$ sits (the start). We count dots from $0$ , so the first dot has taken zero steps.
$k$ — the dot's index: how many gaps you crossed to reach it.
$Δ$ — the fixed gap width from Step 2.

At $k = 0$ : $x_{0} = a + 0 \cdot Δ = a$ . Good — the first dot is the start. ✔

Step 3 — Pinning the last dot gives `linspace`

WHAT. linspace promises that the last dot lands exactly on stop $= b$ . We use that promise to solve for $Δ$ .

WHY. Up to now $Δ$ was unknown. The endpoint promise ( $e n d p o in t = T r u e$ ) is the extra fact that nails it down.

PICTURE. In the figure, the leftmost dot is glued to $a$ and the rightmost to $b$ . If there are num dots total, the last one is dot number $n u m - 1$ (because we started counting at $0$ ).

Set the last dot's value equal to $b$ using the rule from Step 2:

$x_{n u m - 1} = a + (n u m - 1) Δ = b .$

$n u m - 1$ — the index of the last dot (Step 1: one fewer than the count). This is also the number of gaps.
Setting it equal to $b$ is the endpoint promise.

Now just solve for $Δ$ — subtract $a$ , divide by $(n u m - 1)$ :

Step 4 — The `endpoint=False` twist

WHAT. Sometimes you want the last dot removed — np.linspace(a, b, num, endpoint=False). This is common when tiling a repeating pattern (like angles around a circle, where $0$ and $2 π$ are the same point and you don't want both).

WHY. If we drop the final post but keep the same number of dots, the spacing must change. Draw it and see what stays fixed.

PICTURE. The figure overlays two rulers on $[0, 1]$ with $n u m = 5$ . Top (endpoint=True): dots at $0, 0.25, \dots, 1$ , last dot on $b$ . Bottom (endpoint=False): the same 5 dots now stop before $1$ ; the phantom 6th dot (hollow) would have been on $b$ .

The trick: with endpoint=False, NumPy imagines one extra dot at $b$ (the hollow one), spaces all of them evenly, then throws the last one away. So now there are $n u m$ real gaps, not $n u m - 1$ :

$Δ_{False} = \frac{b - a}{n u m} .$

Denominator is $n u m$ now, because the phantom dot adds one more gap.
We keep the first $n u m$ dots and discard the phantom.

Step 5 — A different question: fixed step, not fixed count (`arange`)

WHAT. Now flip the priority. You do not care how many dots you get; you care that each step is exactly step $= s$ wide, and you walk from $a$ until you would reach or pass $b$ .

WHY. This is the mindset of Python's built-in range: "start here, keep stepping by $s$ , stop before $b$ ." The count $N$ is now an output, whatever falls out.

PICTURE. In the figure, we plant $a$ then march right in equal jumps of $s$ . A magenta wall sits at $b$ . We keep a dot only if it lands strictly left of the wall. The wall itself is never a dot — stop is excluded.

Does arange include stop?

No — stop is excluded, exactly like Python range.

Step 6 — Counting the dots: where the ceiling comes from

WHAT. How many dots survive the wall? We derive the count $N$ .

WHY. We want a formula, not a march-and-count each time.

PICTURE. The figure zooms on the last stretch before the wall. Dot number $k$ sits at $a + k s$ (same rule as Step 2). We keep it while $a + k s < b$ , i.e. while $k < \frac{b - a}{s}$ .

So the allowed indices are $k = 0, 1, 2, \dots$ up to (but not including) $q := \frac{b - a}{s}$ .

Why exactly $⌈ q ⌉$ of them? Let us count carefully. The kept indices are all whole numbers $k$ with $0 \leq k < q$ . Reading off the number line: they are $k = 0, 1, 2, \dots$ up to the largest whole number below $q$ . Call that largest index $m$ . Then the kept indices run $0, 1, \dots, m$ , which is $m + 1$ numbers.

If $q$ is a whole number (say $q = 4$ ): the largest whole number strictly below $4$ is $m = 3$ , giving $m + 1 = 4 = ⌈ 4 ⌉$ dots. (The dot at $k = 4$ would land on the wall and is rejected.)
If $q$ is fractional (say $q = 3.33$ ): the largest whole number below is $m = 3$ , giving $m + 1 = 4 = ⌈ 3.33 ⌉$ dots.

In both cases the answer is $⌈ q ⌉$ : the ceiling rounds up, which is exactly "count every integer slot sitting strictly short of the wall." The step figure draws these slots $0, 1, \dots, ⌈ q ⌉ - 1$ as filled dots and the rejected slot on the wall as hollow.

Step 7 — The degenerate & dangerous cases

WHAT. Every function has "what if the input is weird?" corners. We cover them so nothing surprises you: a zero step, a wrong-sign step, num=1, and float drift.

WHY. Contract rule: the reader must never meet a case we skipped. The arange API is "fixed step" — so the two things that can break a step (it being $0$ , or pointing the wrong way) deserve their own picture.

PICTURE. The figure stacks four mini-rulers:

(a) step = 0: np.arange(0, 1, 0). The march never moves — each "next" dot equals the last, so you'd loop forever trying to reach the wall. NumPy refuses: it raises ZeroDivisionError (the formula $q = (b - a) / s$ divides by zero). Never pass step $0$ .
(b) wrong-sign step: np.arange(0, 1, -0.25) (going left while the wall is to the right), or np.arange(1, 0, 0.25) (going right while the wall is to the left). You march away from the wall, so no dot ever satisfies the keep-condition. Result: an empty array []. In the formula, $q = (b - a) / s$ comes out negative, and $⌈ negative ⌉ \leq 0$ means zero dots.
(c) num=1: np.linspace(0, 1, 1) → just $[0]$ . One dot means zero gaps, so $Δ = (b - a) / (n u m - 1)$ would divide by $0$ — NumPy special-cases it and returns only the start.
(d) float drift: np.arange(0, 1, 0.1) — because binary can't store $0.1$ exactly (see Floating-point representation and rounding errors), the marching sum accumulates a tiny error, so the final dot may sneak in at $0.9999 \dots$ or be dropped, making $N$ jump between $10$ and $11$ .

Recall Edge-case quick table

np.linspace(a, b, 1) returns? ::: [a] — one dot, no gaps, no division by zero. np.linspace(a, b, 0) returns? ::: an empty array []. np.arange(0, 1, 0) does what? ::: raises ZeroDivisionError (step 0 is illegal). np.arange(0, 1, -0.25) returns? ::: empty array [] — the step points away from the wall. Safer choice for "N points on an interval"? ::: np.linspace (avoids float drift).

The one-picture summary

This final figure puts both derivations side by side so the shape of each formula is visible at a glance: linspace fixes the two ends and asks "how wide is each of the $n u m - 1$ gaps?"; arange fixes the step width and asks "how many dots fit before the wall?"

Top ruler (linspace): both ends nailed (filled orange), gaps $= n u m - 1$ , so $Δ = \frac{b - a}{n u m - 1}$ .
Bottom ruler (arange): first dot nailed, magenta wall at $b$ excluded (hollow), count $N = ⌈ \frac{b - a}{s} ⌉$ (for a correctly-signed, non-zero step).

Recall Feynman: the whole walkthrough in plain words

Picture a fence. linspace says: "I want exactly 5 posts, one at each end of my yard, spread the fence evenly." Since 5 posts make only 4 rails, you cut each rail as (yard length) ÷ 4 — that's the mysterious "minus one." If you tell it "no post on the far end," it pretends there's a 6th post at the end, spaces all six, then yanks that last post — now it's ÷ 5 instead. arange thinks the opposite way: "I'll take fixed 0.25-metre steps from the start and stop the instant I'd hit or cross the far wall." You never plant a post on the wall, and to count how many posts you got you round the division up, because you fill every step-slot sitting strictly short of the wall. Two traps: a step of zero means you never move, so NumPy throws an error; a step pointing the wrong way marches away from the wall, so you get nothing back — an empty array. And if your step is a messy decimal like 0.1, the computer can't store it exactly, so the marching adds up tiny errors and the last post might wobble in or out — that's the day you switch back to linspace.

Connections

Parent: Array creation (Hinglish)
Floating-point representation and rounding errors — why float arange drifts (Step 7).
Plotting functions with Matplotlib — linspace feeds a smooth x-axis.
NumPy arrays — shape, dtype, ndim — what these functions actually return.
Vectorization vs Python loops — why we build filled arrays instead of looping.

Visual walkthrough — Array creation — np.zeros, np.ones, np.linspace, np.arange, np.random