1.8 Computer memory: how values are stored

Big ideas

• Memory is a huge row of bytes, each of 8 bits. Everything (numbers, text, code) is stored as patterns of bits; 2¹⁰ = 1024 bytes is a kibibyte, and binary 1011 is 8 + 2 + 1 = 11.
• A Python variable is a name that refers to an object somewhere in memory. id(x) shows the address; two names can refer to the same object.
• Ints, floats and strings are immutable: y = x; y += 1 makes y refer to a new object and leaves x alone. Lists (soon) are mutable, so two names for the same list see each other’s changes.
• Floats are binary fractions with limited precision, which is why 0.1 + 0.2 == 0.3 is False. Compare floats with a tolerance or round().
• Function calls stack up frames (their local variables); a frame is freed when the call returns. Python frees objects nobody refers to anymore.

Code you should know

x = 5
y = x
y += 1
print(x, y, x is y)

a = "cat"
b = a
b = b + "s"
print(a, b)
print(0.1 + 0.2, 0.1 + 0.2 == 0.3, round(0.1 + 0.2, 2) == 0.3)

5 6 False
cat cats
0.30000000000000004 False True

print(bin(11), int("1011", 2), 2 ** 10)
print(ord("A"), chr(65), bin(ord("A")))
for n in range(0, 9):
    print(n, format(n, "04b"))

0b1011 11 1024
65 A 0b1000001
0 0000
1 0001
...

Worked example

Common mistakes

• Thinking y = x copies a number “by value” in some special way: both names refer to the same object until one is reassigned; for immutable objects that is indistinguishable from copying.
• Testing float results with ==.
• Mixing up bits and bytes (8 bits per byte).