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

WHAT: shape is passed as one tuple (2, 3) → 2 rows, 3 columns. WHY float: the default dtype of np.zeros is float64, so the entries print with a dot (0.). $\left[\begin{array}{ccc}0.& 0.& 0.\\ 0.& 0.& 0.\end{array}\right]$ Shape (2, 3), dtype float64, six zeros.

A bare 4 (not a tuple) means a 1-D array of length 4. We overrode the default float with dtype=int. Result: array([1, 1, 1, 1]). The dtype is the platform's default integer — typically int64 on 64-bit Linux/macOS, but int32 on some systems (e.g. Windows). The reliable takeaway: it is an integer dtype (note no dots), not the concrete bit-width.

One argument means start=0, step=1, stop=3 (exclusive). array([0, 1, 2]) — an integer dtype (arange keeps integer dtype when all args are ints; the exact width is platform-dependent). The value 3 is not included.

WHY num−1: 5 points create 4 gaps (fenceposts vs gaps — see the top ruler in the figure). $\Delta =\frac{1-0}{5-1}=\mathrm{0.25.}$ Elements $x_k=0+k(0.25)$ for $k=0,1,2,3,4$: [0. , 0.25, 0.5 , 0.75, 1. ]. The stop 1.0 is included (endpoint=True).

$N=\lceil \frac{20-2}{3}\rceil =\lceil 6.0\rceil =6.$ Elements: 2, 5, 8, 11, 14, 17. The last is 17; the next would be 20 which equals stop and is excluded.

$\Delta =\frac{10-0}{10-1}=\frac{10}{9}\approx \mathrm{1.1111.}$ Not 1. To get step exactly 1 with endpoint 10, you need 11 points: np.linspace(0, 10, 11).

By the formula, $N=\lceil (1-0)/0.1\rceil =\lceil 10\rceil =10$, if arithmetic were exact. WHY it wobbles: 0.1 cannot be stored exactly in binary (Floating-point representation and rounding errors). The stored value is slightly less than 0.1, so 10 accumulated steps land at roughly 0.9999999… — just under 1. Since that is < stop, one more value squeezes in, and you can get length 11 with a final entry near 0.9999999999999999. In practice CPython/NumPy here returns length 10 for this exact case, but the point stands: the count is not guaranteed. Never rely on it. Fix: for a known count over an interval, use np.linspace(0, 1, 10, endpoint=False) — deterministic.

$\Delta =(5-5)/(4-1)=0$. Every point sits on top of the other: array([5., 5., 5., 5.]). No error — linspace happily makes a constant array of length num.

The formula does not care about direction: $\Delta =(0-2)/(5-1)=-0.5$, a negative step. [2. , 1.5, 1. , 0.5, 0. ] — counts down, endpoints 2 and 0 both included.

WHY the formula still works: with a negative step, both numerator and denominator flip sign. For np.arange(2, 0, -0.5): $N=\lceil \frac{\text{stop}-\text{start}}{\text{step}}\rceil =\lceil \frac{0-2}{-0.5}\rceil =\lceil 4.0\rceil =4.$ The two minus signs cancel, so $N$ stays positive — exactly what you want (a count can't be negative). Values 2. , 1.5, 1. , 0.5, marching downward, with stop = 0 excluded (just like the ascending case excludes its stop). Sanity check on direction: arange only produces a non-empty array when the step points from start toward stop. np.arange(2, 0, +0.5) would ask "walk up from 2 to reach 0" — impossible, so it returns an empty array of length 0 (the ratio $(0-2)/0.5=-4$ is negative, and NumPy floors the count at 0).

arange way: start 1, step 2, stop just past 19 → np.arange(1, 20, 2). Count $=\lceil (20-1)/2\rceil =\lceil 9.5\rceil =10$. Values 1,3,…,19. ✅ linspace way: 10 evenly spaced points from 1 to 19 (both included): np.linspace(1, 19, 10) → $\Delta =(19-1)/9=2$ → 1,3,…,19. ✅ Both give the same 10 values. Because $\Delta$ came out to a round integer here, linspace is exact.

out = np.zeros(6)
for i in range(6):
    out[i] = i**3

Result: [ 0., 1., 8., 27., 64., 125.] (floats, because the buffer is float64). WHY preallocate: the buffer is one fixed block of memory. Filling it in place avoids the repeated re-allocation and copying that growing a Python list would incur — the standard fast pattern (see Vectorization vs Python loops).

Start from ones and scale: 7 * np.ones((3, 3)). Each of the 9 entries is 7.0. Shape (3, 3). Sum $=9\times 7=63$. (np.full((3,3), 7) is the direct route, but scaling np.ones proves you understand that array creators return real arrays you can do arithmetic on.)

rng.normal(loc, scale, size) draws from a Gaussian with mean loc = 3 and std scale = 2 (Random sampling and distributions). For a large sample the sample mean $\to 3$ and sample std $\to 2$ (with small random wobble that shrinks as size grows). Reproducibility: the seed 0 fixes the generator's internal state, so default_rng(0) on any machine produces the identical stream of numbers — same mean, same std, byte-for-byte.

Use endpoint=False: np.linspace(0, 1, 5, endpoint=False). WHY: with endpoint=False, linspace treats stop as a phantom fencepost it never keeps, so it divides the interval into num gaps: $\Delta =(1-0)/5=0.2$, giving 0, 0.2, 0.4, 0.6, 0.8. This is the deterministic replacement for the drifty np.arange(0, 1, 0.2).

rng.integers(low, high, size) draws uniform integers in $[\text{low},\text{high})$ — high is exclusive, mirroring arange. So each value is one of 10, 11, 12, …, 19. The value 20 can never appear. (If you needed 20 possible, you'd pass high=21 or set endpoint=True.)

Two rulers rule everything. linspace = "give me num marks, both ends painted" → gap (b−a)/(num−1). arange = "step by s, stop before the wall" → count ceil((b−a)/s), and a negative s walks downward (two minus signs keep the count positive). Floats crack arange when the step is fractional, so switch to linspace. zeros/ones are blank cartons (shape is one tuple). And default_rng(seed) is dice with a magic replay word.