How Computers Store Numbers: Binary and Hexadecimal

Everything is 0s and 1s

Your photos, your playlist, this lesson and every Python program you write are all stored the same way: as long rows of 0s and 1s. Why?

A computer's memory and processor are built from billions of tiny electronic switches called transistors. A switch is either off or on. It is easy to build circuits that tell two states apart reliably, even when there is a little electrical noise. So computers use a number system with only two digits: binary. One binary digit is a bit. Eight bits make a byte.

Expectation A1.2 asks you to understand how a computer uses binary, hexadecimal, ASCII and Unicode to represent data. This lesson covers numbers; the next lesson covers text.

Place value, base 10 and base 2

In decimal, the number 307 means 3 × 100 + 0 × 10 + 7 × 1. The places are powers of 10: 1, 10, 100, 1000, ...

Binary works the same way, but the places are powers of 2: 1, 2, 4, 8, 16, 32, 64, 128, ... (from right to left). Each digit is 0 or 1, so a place is either counted or not counted.

To convert binary to decimal, add the place values wherever there is a 1.

Decimal to binary

There are two common methods.

Method 1: subtract powers of 2. Find the largest power of 2 that fits, write a 1 there, subtract, and repeat with what is left. For 77: 64 fits (13 left), 32 does not, 16 does not, 8 fits (5 left), 4 fits (1 left), 2 does not, 1 fits. So 77 = 1001101.

Method 2: divide by 2 repeatedly. Divide by 2 and write down the remainder (0 or 1). Keep dividing the quotient until it reaches 0. Read the remainders from the bottom up. (This uses the // and % you learned in Lesson 4.)

How many values fit in n bits?

Each extra bit doubles the number of patterns:

• 1 bit: 2 patterns (0, 1)
• 2 bits: 4 patterns (00, 01, 10, 11)
• 8 bits (1 byte): 2⁸ = 256 patterns, so the values 0 to 255
• 16 bits: 2¹⁶ = 65 536 patterns

In general, n bits can store 2ⁿ different values. The largest unsigned whole number in n bits is 2ⁿ − 1.

Storage is measured in bytes: a kilobyte (kB) is 1000 bytes, a megabyte (MB) is 1 000 000 bytes and a gigabyte (GB) is 1 000 000 000 bytes. (Some programs use 1024 instead of 1000; the units for those are KiB, MiB and GiB.)

Hexadecimal: a short form for binary

Long rows of bits are hard for people to read. Hexadecimal (hex, base 16) is a compact way to write them. It needs 16 digits, so after 0 to 9 it uses letters: A = 10, B = 11, C = 12, D = 13, E = 14, F = 15.

Because 16 = 2⁴, one hex digit is exactly 4 bits. A byte is always 2 hex digits, from 00 to FF (255).

• Binary to hex: split the bits into groups of 4 from the right, and convert each group.
• Hex to decimal: the places are 1, 16, 256, ... So 2F = 2 × 16 + 15 = 47.

You see hex every day without noticing: web colours like #FF0000 (red) use one byte (two hex digits) each for red, green and blue. Network card (MAC) addresses and error codes are also written in hex.

Binary and hex in Python

Python can write and convert these number systems for you, which is handy for checking your work:

• 0b1011 is a binary literal (11) and 0xFF is a hex literal (255).
• bin(77) gives the string '0b1001101'; hex(214) gives '0xd6'.
• int("1011", 2) reads a string as base 2; int("D6", 16) reads it as base 16.

Why 0.1 + 0.2 is not exactly 0.3

Fractions work in binary too, with places worth 1/2, 1/4, 1/8, and so on. Some decimal fractions, like 0.5 (= 1/2) and 0.25, have exact binary forms. But 0.1 has no exact binary form, just as 1/3 has no exact decimal form (0.3333...). A float stores a very close approximation, so tiny errors appear:

• print(0.1 + 0.2) shows 0.30000000000000004.

This is not a Python bug; almost every language does this. It is why you round floats for display, and why programs that handle money often store whole cents as integers.