Writing Python on paper

Read like a computer

Goal You can run a short Python program by hand, one line at a time, and write down every name and value it uses.

When you write code on paper, nothing tells you that a line is wrong. Your only check is to run the program yourself, half in your head and half on the page. This is called a dry run: you act as the computer, with a pen, one line at a time.

A computer has no idea what your program is for. It does exactly what each line says, in order, and it remembers only what is stored under names. In Python, a name is a label for a value, such as count or items. While you trace, do the same. Do what the line says, not what you meant it to say.

The tool is a trace table. A trace table has one column for each name and one row for each line that runs. Build it in four steps.

1. Number the lines of the program in the margin, starting at 1.
2. Draw the table. The first column is Line. Then one column for each name. The last column is Note, where you write what happened, for example "test is true", or what the program printed.
3. Run the program. Python starts at line 1 and goes down. Each time a line runs, add a row. Write the line number, then the value of every name after that line has finished. Copy unchanged values down from the row above, so that every row can be read on its own.
4. Write a dash (–) for a name that does not exist yet. In Python, a name appears the first time something is stored under it. Using a name before that stops the program with a NameError.

A line that starts with def only creates the function. The lines inside it do not run until somebody calls the function. So a def line gets one row, and its body gets rows later, at the call.

Python shows what belongs together by indentation, the spaces at the start of a line. Lines that are pushed in under a for, if or def belong to it. When you move back out to the left, you have left that block.

A loop line runs many times, so it gets many rows. For a loop of the form for x in items, add one row each time x takes the next item. Write the new value of x. When no items are left, add one last row to show that the loop ends. Unlike C or Java, the name x is still there after the loop, and it keeps the last item.

An if line gets one row. If its test is false, the next row is the first line after the indented block.

When the program calls a function, the function's parameters become new names that start with the values you passed in. Keep them in the same table and say in Note that you are inside the function. When it returns, write the returned value in Note.

def count_big(items, limit):
    count = 0
    for x in items:
        if x > limit:
            count = count + 1
    return count


print(count_big([3, 8, 5], 4))

2

for i in range(1, 4):
    print(i)

for i in range(1, 5):
    print(i)

for i in range(7 / 2):
    print(i)

for i in range(7 // 2):
    print(i)

for i in range(3):
    print(i)
    print("done")

for i in range(3):
    print(i)
print("done")

def add(a, b):
    result = a + b

print(add(1, 2))

def add(a, b):
    result = a + b
    return result

print(add(1, 2))

Draw names and objects

Goal You can draw the names and objects of a Python program at any line, say what = does, and tell mutable objects from immutable ones.

In Python, a name is not a box that holds a value. A name is a label stuck on an object, like a label on a jar. Two labels can be stuck on the same jar. You cannot see that in the code, so you have to draw it. Use the same picture every time.

Draw two columns: Names on the left and Objects on the right.

Objects. Every value is an object: the number 5, the text "hi", the list [1, 2]. Draw each object as a box, and write its type and value, such as int 10 or str "hi". Give each object a label, O1, O2, O3, in the order it is made. A list is a box with one cell for each item. A cell that holds a number or a piece of text may show the value directly. A cell that holds a list or another object that can change has an arrow to it.

Names. A name is a label on the left with exactly one arrow to an object. A name has no value of its own. The names inside a function are drawn in a frame, a box around them, that exists only while the function runs.

What = does. The statement b = a never copies anything. It puts a second label, b, on the object that a already points at. The statement a = 5 finds or makes the object 5 and moves the arrow of a to it. Assignment moves arrows. It does not copy objects.

Immutable and mutable. An immutable object can never change after it is made. Numbers, strings, tuples and None are immutable. A mutable object can change in place. Lists, dicts and sets are mutable, and so are objects of your own classes.

With an immutable object, s = s + "!" does not touch the old string. It makes a new string and moves the arrow of s. Any other label on the old string still sees the old text. With a mutable object, b.append(3) changes the list itself. Every label on that list sees the change. Two names for one object is called aliasing.

Copying. b = a.copy() makes a new list with the same cells. It is a shallow copy: the cells hold arrows to the same items as before. If an item is itself a list, both outer lists share it. Draw the arrows and you will see this.

Function calls. A call makes a new frame. Its parameter names are new labels on the same objects the caller passed in. So a function can change a mutable argument in place. But a statement such as param = something only moves the label inside the frame.

Equal and same. a == b asks whether two objects look equal. a is b asks whether the two names are on the same object.

Garbage. An object with no label and no arrow into it can never be reached again. Python removes it. Cross it out in the picture.

a = [1, 2]
b = a
b.append(3)
c = a.copy()
c.append(4)
x = 10
y = x
y = y + 1
nested = [a, [5]]
dup = nested.copy()
dup[1].append(6)
dup[0] = [0]
print(a, b, c)
print(x, y)
print(nested)
print(dup)

[1, 2, 3] [1, 2, 3] [1, 2, 3, 4]
10 11
[[1, 2, 3], [5, 6]]
[[0], [5, 6]]

scores = [70, 80]
backup = scores
scores.append(90)

scores = [70, 80]
backup = scores.copy()
scores.append(90)

def add_item(item, items=[]):
    items.append(item)
    return items

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

grid = [[0] * 3] * 3
grid[0][0] = 1

grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1

s = "hi"
s[0] = "H"

s = "hi"
s = "H" + s[1:]

Syntax to memorise

Goal You can write the eight Python skeletons below from memory, shortest first, with every colon and indent in place.

Some code cannot be worked out on the spot. You must know its shape without looking. The eight shapes in this lesson are the ones Python needs again and again. They are short enough to learn by heart. Learn them in this order, shortest first, and add the next one only when the last is solid.

1. def, with if, elif and else. 2. for. 3. f-strings. 4. List methods. 5. Dict methods. 6. Comprehensions. 7. try and except. 8. A class with __init__.

How to memorise: cover the page and write the shape on paper. Compare it with the page, character by character. Tick it only when it is right with no peeking. Do it again tomorrow. A shape that you write correctly three days in a row is learned.

The program below contains all eight shapes, each marked with a comment such as (2). Read it once. Then cover it and write each shape on its own, in a few lines of your own paper.

Two things that you must never forget. Every line that opens a block ends with a colon: def, if, elif, else, for, while, class, try, except. And every block is indented by the same amount, usually four spaces.

List methods. words.append(x) adds at the end. words.pop() removes the last item and gives it back. words.insert(i, x) puts x at position i. words.remove(x) removes the first x. words.sort() sorts in place and returns None. sorted(words) returns a new sorted list. len(words) is the length. words[0] is the first item, words[-1] the last, and words[1:3] is a slice: positions 1 and 2, because the end is not included.

Dict methods. d[key] = value stores. d[key] reads, and stops with a KeyError when the key is missing. d.get(key, default) reads and gives the default when the key is missing. key in d asks whether the key is there. d.keys(), d.values() and d.items() give the keys, the values and the (key, value) pairs. del d[key] removes.

# (1) def, with if, elif and else
def average(nums):
    return sum(nums) / len(nums)


def label(score):
    if score >= 8:
        return "high"
    elif score >= 4:
        return "mid"
    else:
        return "low"


# (4) list methods
words = ["pear", "fig", "apple"]
words.append("kiwi")
words.sort()
last = words.pop()
print(words, last, len(words))

# (5) dict methods, and (2) for
lengths = {}
for w in words:
    lengths[w] = len(w)
for key, value in lengths.items():
    # (3) f-string
    print(f"{key} has {value} letters")
print(lengths.get("plum", 0), "fig" in lengths)

# (6) comprehensions
squares = [n * n for n in range(4)]
long_words = [w for w in words if len(w) > 3]
sizes = {w: len(w) for w in words}
print(squares, long_words, sizes)


# (8) class and __init__
class Counter:
    def __init__(self, name):
        self.name = name
        self.total = 0

    def add(self, amount):
        self.total += amount


c = Counter("steps")
c.add(5)
c.add(7)
print(f"{c.name}: {c.total}, average {average([c.total, 8]):.1f}, {label(c.total)}")

# (7) try and except
try:
    n = int("12a")
except ValueError:
    n = -1
print(n)

['apple', 'fig', 'kiwi'] pear 3
apple has 5 letters
fig has 3 letters
kiwi has 4 letters
0 True
[0, 1, 4, 9] ['apple', 'kiwi'] {'apple': 5, 'fig': 3, 'kiwi': 4}
steps: 12, average 10.0, high
-1

words = ["pear", "fig"]
ordered = words.sort()

words = ["pear", "fig"]
ordered = sorted(words)

ages = {"Leon": 20}
age = ages["Emma"]

ages = {"Leon": 20}
age = ages.get("Emma", 0)

words = ["pear", "fig"]
n = words.length
m = words.size()

words = ["pear", "fig"]
n = len(words)

name = "Mia"
print("Hello {name}")

name = "Mia"
print(f"Hello {name}")

Common handwriting mistakes

Goal You can read your own Python answer a second time, as the interpreter would, and catch the slips that would otherwise cost marks.

On a computer, Python stops you at the first syntax error and tells you the line. On paper, nobody stops you, and every one of these slips costs marks even though it has nothing to do with whether you understand the problem. So you must be your own interpreter.

When your answer is finished, read it a second time. This time do not ask whether the logic is right. Ask only whether the form is right. Use this list, and tick each item with your pen.

1. Every line that opens a block ends with a colon: def, if, elif, else, for, while, class, try, except.
2. The lines of a block are indented by the same amount. Lines after the block move back to the left.
3. Every ( [ { has its partner, and every opening quote has a closing quote of the same kind.
4. = stores a value. == asks a question. There is no ++: write += 1.
5. Use and, or, not. Use elif, not else if. Write True, False and None with a capital letter.
6. Names are case sensitive: count and Count are different names.
7. Every method of a class has self as its first parameter, and reads and writes attributes with self.
8. A function that should give a value back has a return. Without one, it gives back None.
9. Text and numbers do not mix: "5" + 1 is an error. Convert with int() or str().
10. Python does not tell you off for a name you misspelled until the line runs. Check each name against where it was first stored.

Below are four pairs that cost the most marks. In each pair the first block is what people write, and the second block is the repair.

def double(x)
    return x * 2

for i in range(3):
print(i)

def double(x):
    return x * 2

for i in range(3):
    print(i)

if x > 0 && y > 0:
    count++
else if x == 0:
    print("zero")

if x > 0 and y > 0:
    count += 1
elif x == 0:
    print("zero")

if x = 3:
    print("three")
if x == 3 or 4:
    print("three or four")

if x == 3:
    print("three")
if x == 3 or x == 4:
    print("three or four")

class Dog:
    def __init__(name):
        self.name = name

    def rename(self, new):
        name = new

class Dog:
    def __init__(self, name):
        self.name = name

    def rename(self, new):
        self.name = new

Mark yourself

Goal You can mark your own paper answer honestly against a rubric, find where the marks went, plan tomorrow's practice, and write under time.

On paper, a page of writing can look finished and still be wrong. Marking yourself fixes that. You compare your answer with a rubric. A rubric is a list of lines, each worth a number of marks, each describing something that you can see in the answer. Be strict. The mark that counts is the one a stranger would give.

How to read a rubric, line by line.

1. Read one line. Ask: what exactly would I see in a correct answer?
2. Find that thing in your answer and touch it with the tip of your pen. If you can point to it, tick the line and write its marks. If you cannot point to it, the line is worth zero.
3. Do not give half marks for "nearly". Give part of a line only if the rubric says how it splits.
4. Check every path. A line such as "handles the empty string" is zero if only the normal case works.
5. Add up the lines. Write the total as marks out of the maximum on the page.

How to find where the marks went. Put each lost mark into one of four boxes. Idea: I did not know how to solve it. Recall: I knew, but could not remember the syntax or the method name. Slip: a small mistake in something I did know, such as a missing colon or a missing return. Time: I ran out of time. Count each box. The biggest box tells you what to work on. Idea: reread the lesson. Recall: more cover-and-write practice. Slip: the interpreter pass from the last lesson and a tiny test. Time: practise planning.

What to do the next day. First, rewrite the same answer on a blank page without looking. Second, do a different question of the same kind. Third, mark both again. Repeat after three days and after a week. When the biggest box changes, you are improving.

How to write under time.

1. Plan first. Use the first tenth of the time. Write the def line and three or four comment lines that name the steps. Do not skip this.
2. Leave a blank line between blocks of code. You will need room to insert a line you forgot. Python is sensitive to indentation, so write the indentation as clearly as you can, and use the same four spaces each time.
3. Name things clearly: count, not c; longest, not l. Clear names stop you from mixing up two names.
4. Test with a tiny input, by hand. When the code is written, run it on the smallest case: one item, an empty list, a one-letter word. Then run one case that repeats a value. This takes a minute and finds most boundary errors.
5. Spend about one minute per mark. If you are stuck on a part, write a comment saying what you would do, move on, and come back.
6. Leave two minutes for the interpreter pass.

On the Practice page, the questions of kind Write code have a Paper mode with a timer, a model answer and a rubric with tick boxes. Use it exactly like this lesson: write on paper, then mark.

def count_letters(word):
    counts = {}
    for ch in word:
        counts[ch] = counts.get(ch, 0) + 1


print(count_letters("aba"), "(expected {'a': 2, 'b': 1})")

None (expected {'a': 2, 'b': 1})

counts = {}
for ch in word:
    counts[ch] += 1

counts = {}
for ch in word:
    counts[ch] = counts.get(ch, 0) + 1

total = 0
for i in range(1, len(items)):
    total += items[i]

total = 0
for x in items:
    total += x

def total(items):
    s = 0
    for x in items:
        s += x
    print(s)

def total(items):
    s = 0
    for x in items:
        s += x
    return s