Module 02: Representing information

A bit has two possible values, 0 and 1. An eight-bit byte has 256 possible patterns. Meaning comes from an agreed interpretation: the same byte might represent an integer, part of a character, or an instruction. In binary, positions from right to left have weights 1, 2, 4, 8 and so on. Thus 1101 means 8 + 4 + 1 = 13. Hexadecimal uses weights 1, 16, 256; digits A–F mean 10–15. Each hexadecimal digit corresponds to four bits, so 0x2D is 0010 1101, or 45 decimal.

To encode a nonnegative integer, repeatedly divide by 2, record the remainders, then read them in reverse. Leading zeroes change the chosen width, not the unsigned value.

With w bits there are 2^w patterns. Unsigned integers range from 0 to 2^w−1; eight bits allow 0–255. Adding one to 255 requires nine bits. A fixed-width system must define what happens: reject, wrap, saturate or report an error. These are different behaviours, not interchangeable repairs. Our converter rejects values outside its range.

Python integers grow as needed, subject to memory, so Python's 255 + 1 does not itself wrap at eight bits. To model eight-bit wrapping explicitly, use (value + 1) % 256. Storage formats and hardware interfaces still impose widths even when your language's integer type does not.

Two's complement assigns the highest bit weight −2^(w−1), with ordinary positive weights for the others. At eight bits, 11111111 is −128+127 = −1; 10000000 is −128. The range is −128 to 127, not −127 to 127. Decode an unsigned pattern u by subtracting 256 when its top bit is set.

A multibyte value also needs byte order. For 0x1234, big-endian storage puts 12 then 34; little-endian puts 34 then 12. This is a byte-order choice, separate from signedness. When exchanging data, specify width, signedness and byte order together.

Unicode assigns code points to text symbols; UTF-8 encodes those code points into bytes. ASCII characters take one UTF-8 byte, while many other code points take several. The string A中 has two code points but four UTF-8 bytes. Python str represents text; bytes represents a byte sequence. Encode when crossing a byte-oriented boundary, and decode using the agreed encoding when reading.

A displayed character can comprise multiple code points, such as a base letter plus a combining accent. Therefore code-point length is not always the number of visible characters. Splitting encoded text at an arbitrary byte boundary can cut a multibyte sequence and make decoding fail. Store and transmit the encoding agreement as part of the format.

A floating-point format stores a sign, a scaled significand and an exponent. Finite binary fractions have denominators that are powers of two. Decimal 0.1 is 1/10, so its binary expansion repeats and finite storage rounds it. On usual Python platforms, 0.1 + 0.2 differs slightly from 0.3. This is a representation issue, not evidence that addition is arbitrary.

Compare approximate measurements with tolerances chosen for the problem, using both relative and absolute tolerance near zero. For exact money amounts, consider integer minor units or Decimal constructed from strings. Decimal also has a finite precision context: it is not exact for every possible division. Fractions can preserve rational values exactly at the cost of growing numerators and denominators.

Download each script and run it in a terminal with Python 3.11 or later: python m02_binary.py. On Windows, py -3 is an alternative; on some systems use python3. The labs use only the standard library. Predict the result before running, then complete the variations. Run without -O so assertions remain enabled. Outputs below were captured by the builder. Code and output are identical in both language editions.

Follow the remainders through the loop. The script checks the round trip and explicitly rejects overflow.

Download m02_binary.py

"""Base conversion and fixed-width signed interpretation."""
def binary(value, width=8):
    if not 0 <= value < 2 ** width:
        raise ValueError("value does not fit unsigned width")
    bits = []
    for _ in range(width):
        bits.append(str(value % 2))
        value //= 2
    return "".join(reversed(bits))

for value in [0, 13, 127, 128, 255]:
    bits = binary(value)
    signed = value if value < 128 else value - 256
    assert int(bits, 2) == value
    print(f"{bits}: unsigned={value:3}, signed={signed:4}, hex={value:02x}")
try:
    binary(256)
except ValueError:
    print("256 rejected at width 8")
else:
    raise AssertionError("overflow must be rejected")

00000000: unsigned=  0, signed=   0, hex=00
00001101: unsigned= 13, signed=  13, hex=0d
01111111: unsigned=127, signed= 127, hex=7f
10000000: unsigned=128, signed=-128, hex=80
11111111: unsigned=255, signed=  -1, hex=ff
256 rejected at width 8

1. Predict the output for 42.
2. Use width 4 and test 15 and 16.
3. Explain why the signed interpretation changes at 128.

Run the text round trip and compare float and Decimal. The truncated text case deliberately verifies an error.

Download m02_text_float.py

"""Separate text from bytes, and approximate numbers from decimal arithmetic."""
from decimal import Decimal
from math import isclose

text = "A中"
encoded = text.encode("utf-8")
print("code points:", len(text), "bytes:", len(encoded), "hex:", encoded.hex())
assert encoded.decode("utf-8") == text
print("float:", 0.1 + 0.2, "exact equality:", 0.1 + 0.2 == 0.3)
assert isclose(0.1 + 0.2, 0.3, rel_tol=1e-12, abs_tol=1e-12)
exact = Decimal("0.1") + Decimal("0.2")
print("decimal:", exact)
assert exact == Decimal("0.3")
try:
    encoded[:2].decode("utf-8")
except UnicodeDecodeError:
    print("truncated UTF-8 rejected")

code points: 2 bytes: 4 hex: 41e4b8ad
float: 0.30000000000000004 exact equality: False
decimal: 0.3
truncated UTF-8 rejected

1. Replace the text with ASCII-only ABC.
2. Try encoding the original text as ASCII.
3. Compare Decimal('0.1') with Decimal(0.1). Explain the difference.

Try before opening the solution. ★ applies an idea; ★★ combines ideas; ★★★ asks for design or proof.

Choose an answer for feedback; reset to retry. A text answer key is available without JavaScript.

• Python floating-point tutorial — Read the representation-error explanation; describe when a tolerance is appropriate.
• Python Unicode HOWTO — Read encodings and decoding errors; distinguish str and bytes.

Encode 29, decode an eight-bit negative value, and explain why A中 needs four UTF-8 bytes. Choose a representation for a catalogue's book count and price. Next, Module 03 builds a program that uses these values.