Number systems & representation

1 · Positional number systems & conversions essential

A number system has a base (radix): the number of distinct digits. Each position is a power of the base. Decimal uses 10 digits (0–9); binary uses 2 (0–1); octal 8; hexadecimal 16 (0–9 then a–f). Hardware is binary because a wire is either high or low — one bit. We group bits into hex because each hex digit is exactly 4 bits (a nibble), so hex is a compact human-readable view of raw bits.

Worked conversion — 156 to binary (repeated division by 2, read remainders bottom-up):

Reading remainders from bottom to top gives 10011100. Group into nibbles: 1001 1100 = 0x9C. And 9*16 + 12 = 156. Everything checks out.

bases.pyn = 156
print("bin:", bin(n))          # 0b prefix
print("oct:", oct(n))
print("hex:", hex(n))
# parse a string in any base with int(str, base)
print("0x9C ->", int("9C", 16))
print("0b10011100 ->", int("10011100", 2))
# format without prefix, zero-padded to 8 bits
print("padded:", format(n, "08b"), format(n, "02x"))

bin: 0b10011100
oct: 0o234
hex: 0x9c
0x9C -> 156
0b10011100 -> 156
padded: 10011100 9c

2 · Signed vs unsigned & two's complement essential

A fixed-width integer is just N bits. Unsigned reads all N bits as a magnitude: range 0 … 2^N − 1. Signed must also encode negatives. The winning scheme is two's complement: the top bit has weight −2^(N−1) instead of +2^(N−1). For 8 bits the range becomes −128 … +127.

Why two's complement and not a simple sign bit? Because addition and subtraction use the same adder circuit for signed and unsigned — there is exactly one representation of zero, and a − b is just a + (two's-complement of b). To negate: invert all bits, then add 1.

twos.pyBITS = 8
MOD = 1 << BITS            # 256

def to_twos(x):
    "encode a signed int into its 8-bit two's-complement pattern"
    return x % MOD          # Python's % handles negatives for us

def from_twos(bits):
    "decode an 8-bit pattern back to a signed int"
    return bits - MOD if bits >= (1 << (BITS - 1)) else bits

for v in (5, -5, -1, -128, 127):
    b = to_twos(v)
    print(f"{v:>5} -> {b:08b} -> back {from_twos(b)}")

    5 -> 00000101 -> back 5
   -5 -> 11111011 -> back -5
   -1 -> 11111111 -> back -1
 -128 -> 10000000 -> back -128
  127 -> 01111111 -> back 127

3 · Fixed width & integer overflow intermediate

Real hardware integers are a fixed width (8/16/32/64 bits). Add past the top and the value wraps around modulo 2^N — this is the source of countless bugs (the Gangnam-style view counter, the Ariane 5 crash lineage, timestamp rollovers). Python's own int is arbitrary precision so it never overflows — which is exactly why we must simulate a fixed width to see the effect.

overflow.pyMASK = 0xFF                 # keep only the low 8 bits

def add8_unsigned(a, b):
    return (a + b) & MASK

def add8_signed(a, b):
    r = (a + b) & MASK
    return r - 256 if r >= 128 else r      # reinterpret as two's complement

print("255 + 1 unsigned ->", add8_unsigned(255, 1))   # wraps to 0
print("200 + 100 unsigned ->", add8_unsigned(200, 100))
print("127 + 1 signed   ->", add8_signed(127, 1))     # overflow to -128
print("Python has no limit:", 2 ** 100)

255 + 1 unsigned -> 0
200 + 100 unsigned -> 44
127 + 1 signed   -> -128
Python has no limit: 1267650600228229401496703205376

4 · Fixed-point, floating-point & IEEE-754 advanced

Integers can't hold fractions. Fixed-point puts an imaginary binary point at a set position (money as integer cents). Floating-point stores a number like scientific notation: sign × 1.mantissa × 2^exponent, so the point 'floats'. The universal format is IEEE-754. A 64-bit double is 1 sign bit + 11 exponent bits + 52 fraction bits (exponent bias 1023).

Let's decode a real double with struct — pack the float to 8 bytes, read the raw integer, and pull the fields apart:

float_decode.pyimport struct

x = 0.15625              # a value that is exact in binary
bits = struct.unpack(">Q", struct.pack(">d", x))[0]   # 64-bit pattern
print("raw bits:", format(bits, "064b"))

sign =  bits >> 63
exp  = (bits >> 52) & 0x7FF          # 11 exponent bits
frac =  bits & ((1 << 52) - 1)       # 52 fraction bits
print("sign =", sign, " exp =", exp, " (unbiased", exp - 1023, ")")
value = (-1) ** sign * (1 + frac / 2 ** 52) * 2 ** (exp - 1023)
print("reconstructed:", value)

raw bits: 0011111111000100000000000000000000000000000000000000000000000000
sign = 0  exp = 1020  (unbiased -3 )
reconstructed: 0.15625

0.15625 = 1.25 × 2^−3, so the unbiased exponent is −3 and the mantissa is 1.25 — exactly reconstructed. But most decimals are not exact in base 2, which is the famous gotcha:

point_one.pya = 0.1 + 0.2
print("0.1 + 0.2 =", a)
print("== 0.3 ?  ", a == 0.3)
print("full digits:", format(a, ".17f"))
from decimal import Decimal
print("what 0.1 really is:", Decimal(0.1))

0.1 + 0.2 = 0.30000000000000004
== 0.3 ?   False
full digits: 0.30000000000000004
what 0.1 really is: 0.1000000000000000055511151231257827021181583404541015625

5 · Encodings: ASCII, Unicode & UTF-8 intermediate

Text is numbers too. ASCII maps 128 characters to 7-bit codes (A=65). Unicode assigns every character a code point (e.g. U+00E9 for é, U+1F600 for 😀) — that's an abstract number, not bytes. UTF-8 is the dominant encoding: it stores a code point in 1–4 bytes, is backwards-compatible with ASCII, and is what the web runs on.

encodings.pys = "café 😀"
print("chars:", list(s))
print("code points:", [hex(ord(c)) for c in s])
raw = s.encode("utf-8")
print("utf-8 bytes:", raw, "len", len(raw))
# decode raw bytes straight from an integer list
print("back:", raw.decode("utf-8"))
# note: 6 characters but more bytes (é=2, 😀=4)

chars: ['c', 'a', 'f', 'é', ' ', '😀']
code points: ['0x63', '0x61', '0x66', '0xe9', '0x20', '0x1f600']
utf-8 bytes: b'caf\xc3\xa9 \xf0\x9f\x98\x80' len 10
back: café 😀

6 · Bitwise operators & bit tricks advanced

bittricks.py# 1. test / set / clear / toggle bit i with a mask
flags = 0b0000
flags |= (1 << 2)                 # set bit 2
print("after set bit2:", format(flags, "04b"))
print("bit2 set?", bool(flags & (1 << 2)))
flags &= ~(1 << 2)                # clear bit 2
print("after clear:", format(flags, "04b"))

# 2. XOR swap two ints with no temp variable
a, b = 12, 25
a ^= b; b ^= a; a ^= b
print("swapped:", a, b)

# 3. popcount: how many 1-bits (Python 3.10+: int.bit_count)
n = 0b10110101
print("popcount:", bin(n).count("1"))

# 4. classic: is n a power of two?  (only one bit set)
def is_pow2(n): return n > 0 and (n & (n - 1)) == 0
print("64 pow2?", is_pow2(64), " 65 pow2?", is_pow2(65))

after set bit2: 0100
bit2 set? True
after clear: 0000
swapped: 25 12
popcount: 5
64 pow2? True  65 pow2? False

Knowledge check check yourself

n = 205
print(bin(n), oct(n), hex(n))        # 0b11001101 0o315 0xcd
print(format(n, '08b'))              # 11001101
assert int('11001101', 2) == 205
assert int('315', 8) == 205
assert int('cd', 16) == 205
print('all round-trip to', 205)

def to_i8(x):
    if not -128 <= x <= 127:
        raise ValueError('out of range for int8')
    return x % 256

def from_i8(bits):
    return bits - 256 if bits & 0x80 else bits

for v in (-128, -1, 0, 1, 127):
    assert from_i8(to_i8(v)) == v, v
print('round-trip OK; -1 ->', format(to_i8(-1), '08b'))
# round-trip OK; -1 -> 11111111

import math
from decimal import Decimal

s = 0.1 + 0.2
print(format(s, '.17f'))                 # 0.30000000000000004
print(s == 0.3)                          # False
print(math.isclose(s, 0.3))              # True  (tolerant compare)
print(Decimal('0.1') + Decimal('0.2'))   # 0.3   (exact, from strings)
# money: store cents as int -> 10 + 20 == 30, no float at all

import struct

def decode_f64(b8):
    bits = struct.unpack('>Q', b8)[0]
    sign = bits >> 63
    exp  = (bits >> 52) & 0x7FF
    frac = bits & ((1 << 52) - 1)
    value = (-1)**sign * (1 + frac/2**52) * 2**(exp - 1023)
    return sign, exp - 1023, frac, value

print(decode_f64(struct.pack('>d', 1.0)))
print(decode_f64(struct.pack('>d', -0.15625)))
# (0, 0, 0, 1.0)
# (1, -3, 1125899906842624, -0.15625)

class BitFlags:
    def __init__(self, names):
        self.pos = {n: i for i, n in enumerate(names)}
        self.state = 0
    def _m(self, name): return 1 << self.pos[name]
    def set(self, n):    self.state |=  self._m(n); return self
    def clear(self, n):  self.state &= ~self._m(n); return self
    def toggle(self, n): self.state ^=  self._m(n); return self
    def is_set(self, n): return bool(self.state & self._m(n))
    def dump(self):      return format(self.state, f'0{len(self.pos)}b')

f = BitFlags(['read', 'write', 'exec'])
f.set('read').set('exec')
print(f.dump(), f.is_set('read'), f.is_set('write'))  # 101 True False
f.clear('read')
print(f.dump())                                       # 100

def inet_checksum(data: bytes) -> int:
    if len(data) % 2:
        data += b'\x00'
    s = 0
    for i in range(0, len(data), 2):
        s += (data[i] << 8) | data[i+1]        # big-endian 16-bit word
    while s >> 16:
        s = (s & 0xFFFF) + (s >> 16)           # fold carries
    return (~s) & 0xFFFF                        # one's complement

msg = b'HELLO-WORLD!'
cksum = inet_checksum(msg)
packet = msg + bytes([cksum >> 8, cksum & 0xFF])
print('checksum:', hex(cksum))
print('verify good packet ->', inet_checksum(packet))     # 0 == valid

corrupt = bytearray(packet); corrupt[0] ^= 0x01           # flip one bit
print('verify corrupt   ->', inet_checksum(bytes(corrupt)))  # non-zero