zeros, ones, full & empty

Before the season starts you often know the shape of your data (say 3 players × 14 matches) but not the values. Instead of typing 42 zeros by hand, NumPy can create a ready-made array of that shape — a "scorecard template" you fill in later. This is called pre-allocation.

Definition

np.zeros, np.ones, np.full and np.empty create a new array of a given shape, filled respectively with 0, 1, a chosen fill value, or uninitialised (arbitrary leftover) memory. Their _like versions (zeros_like, ones_like, full_like, empty_like) take the shape and dtype from an existing array.

• Shape — an int for 1D (5) or a tuple for more dimensions ((2, 4)).
• Fill value — the value every element starts with.
• Uninitialised — np.empty does not write anything into the memory, so it contains whatever bytes were there before. It is slightly faster, but you must overwrite every element.
• Pre-allocation — creating the full-size array first and filling it later, instead of growing it with np.append (slow).

Syntax

np.zeros(shape, dtype=float)
np.ones(shape, dtype=float)
np.full(shape, fill_value, dtype=None)
np.empty(shape, dtype=float)

np.zeros_like(a, dtype=None)
np.ones_like(a, dtype=None)
np.full_like(a, fill_value, dtype=None)
np.empty_like(a, dtype=None)

Example — zeros, ones and full

import numpy as np
print(np.zeros(5))
print(np.zeros((2, 4)))
print(np.zeros(5, dtype=int))
print(np.ones(4))
print(np.ones((2, 3), dtype=int))
print(np.full(5, 100))
print(np.full((2, 3), 6.5))
print(np.full(3, 4).dtype, np.full(3, 4.0).dtype, np.full(3, True).dtype)
print(np.full((2, 2), "DNB"))

[0. 0. 0. 0. 0.]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]
[0 0 0 0 0]
[1. 1. 1. 1.]
[[1 1 1]
 [1 1 1]]
[100 100 100 100 100]
[[6.5 6.5 6.5]
 [6.5 6.5 6.5]]
int64 float64 bool
[['DNB' 'DNB']
 ['DNB' 'DNB']]

How it works:

• zeros and ones give floats by default — notice the dots (0., 1.). Pass dtype=int for integers.
• For 2D, the shape is a tuple: (2, 4) = 2 rows, 4 columns.
• np.full infers its dtype from the fill value: 4 → int64, 4.0 → float64, True → bool, "DNB" (Did Not Bat) → string.

Example — np.empty and pre-allocation

import numpy as np
e = np.empty(3)
print(e.shape, e.dtype)
e[:] = [10, 20, 30]
print(e)

(3,) float64
[10. 20. 30.]

We deliberately do not print e before filling it: its contents are arbitrary and change from run to run (sometimes it even looks like zeros, which fools beginners). Only use empty when you are about to overwrite every element.

import numpy as np
# Pre-allocate, then fill match by match
season_runs = np.zeros(6, dtype=int)
match_scores = [34, 77, 0, 51, 103, 19]
for i, score in enumerate(match_scores):
    season_runs[i] = score
print(season_runs)
print("Total:", season_runs.sum())

[ 34  77   0  51 103  19]
Total: 284

Example — the _like functions

import numpy as np
team = np.array([[72, 45, 88],
                 [56,  0, 74]])
print(np.zeros_like(team))
print(np.ones_like(team))
print(np.full_like(team, 50))
print(np.full_like(team, 7.9))
print(np.zeros_like(team, dtype=float))
print(np.empty_like(team).shape)

[[0 0 0]
 [0 0 0]]
[[1 1 1]
 [1 1 1]]
[[50 50 50]
 [50 50 50]]
[[7 7 7]
 [7 7 7]]
[[0. 0. 0.]
 [0. 0. 0.]]
(2, 3)

How it works: the result has the same shape and dtype as team (int64). That is why full_like(team, 7.9) gives 7 — the fill value is cast to int. Override with dtype=float when needed.

Comparison

Common mistakes

• ❌ np.zeros(2, 3) → TypeError: Cannot interpret '3' as a data type (the 2nd argument is the dtype). ✅ np.zeros((2, 3)) — pass the shape as one tuple.
• ❌ Expecting np.zeros(5) to give integers. ✅ It gives floats; add dtype=int.
• ❌ Reading values from np.empty before writing them. ✅ Use zeros if you are not sure you will fill every element.
• ❌ np.full_like(int_array, 7.9) and expecting 7.9. ✅ Add dtype=float.

Interview tip

Q: What is the difference between np.zeros and np.empty? A: Both allocate an array of the given shape. zeros writes 0 into every element; empty skips that step, so it is marginally faster but contains arbitrary leftover values. Use empty only when every element will be overwritten immediately.