dtypes, precision and casting

Lesson 1 said an array has one dtype for all its elements. This lesson is about what that dtype actually is: a fixed-width box, and a rule for what the bits inside it mean.

Nearly every dtype surprise comes from the box being too small. Get comfortable with that one idea and the rest is bookkeeping.

Integers

int8, int16, int32, int64 — 1, 2, 4 and 8 bytes. A byte holds 256 patterns, so int8 spans -128 to 127. Drop the sign and uint8 spans 0 to 255, which is precisely why every image format uses it.

Never guess the limits — ask:

np.iinfo(np.int8)      # min=-128, max=127
np.iinfo(np.uint8)     # min=0,    max=255
np.finfo(np.float32)   # precision and range for floats

The default int is platform-dependent

Worth knowing before it confuses you. np.arange(12).dtype is int64 on a normal 64-bit machine — but this lab runs on a 32-bit platform, so the plain int here is int32: four bytes, not eight.

That's why the lesson data is created with an explicit dtype=np.int64. It means the byte arithmetic in these lessons matches what you'll see on your own machine. If you ever depend on a specific width, spell it out — don't rely on the default.

Overflow is silent

This is the one to remember. Python integers grow as large as you like. NumPy integers do not — they wrap:

np.array([127], dtype=np.int8) + 1     # [-128]
np.array([250], dtype=np.uint8) + 10  # [4]
np.array([0], dtype=np.uint8) - 1     # [255]

No exception, no warning, just a wrong number. If you brighten a uint8 image by adding 60, every pixel above 195 wraps to near-black and your sunset grows holes. The fix is always the same shape: widen, compute, clip, narrow back.

np.clip(photo.astype(int) + 60, 0, 255).astype(np.uint8)

Two wrinkles worth knowing, both new in NumPy 2. A single NumPy scalar overflowing does raise a RuntimeWarning — but a whole array overflowing stays silent, and arrays are what you'll be working with. And writing an out-of-range value literally is now an error rather than a wrap:

np.array([300], dtype=np.uint8)     # OverflowError — caught at creation
np.array([300]).astype(np.uint8)   # [44] — casting still wraps

Floats are approximations

float64 — the default — carries roughly 16 significant digits; float32 about 7. Neither can store 0.1 exactly, because a tenth isn't a finite sum of halves any more than a third is a finite decimal.

So never compare floats with ==:

0.1 + 0.2 == 0.3               # False
np.isclose(0.1 + 0.2, 0.3)     # True
np.allclose(a, b)              # for whole arrays

float32 halves your memory and is often plenty — it's the default in most deep learning. Just know you've traded away precision to get it.

Promotion

Combine two dtypes and NumPy picks the narrowest type that holds both, always widening: int8 + int64 → int64, int + float → float. It happens silently and is usually what you want. The exception worth watching is that dividing integers always gives you floats, even when it divides evenly.

Converting on purpose

.astype() is the explicit conversion, and it always copies. Going narrow truncates towards zero rather than rounding:

np.array([1.9, 2.9]).astype(int)          # [1 2]  — truncated
np.round([1.9, 2.9]).astype(int)         # [2 3]  — rounded first
np.array([300]).astype(np.uint8)         # [44]   — narrowing overflows too

And you can set the dtype at creation: np.array([1, 2], dtype=np.float32), np.zeros(5, dtype=int), np.arange(5, dtype="uint8"). Strings, booleans and dates all have dtypes too — bool is one byte per element, and True behaves as 1 in arithmetic, which is the trick behind counting with masks.