Programming further

A list (called an array in exams and in other languages) stores many values under one name, in order. Each value sits in a numbered slot. The number is its index.

scores = [12, 45, 33, 50]

A list can hold other lists. A list of lists is a 2D list: a grid with rows and columns, like a seating plan or a spreadsheet.

seats = [["Ana", "Ben", "Cai"],
         ["Dev", "Eli", "Fay"],
         ["Gus", "Hana", "Iqra"]]
print(seats[1][2])

Looping over a list

for s in scores:
    print(s)

for i in range(len(scores)):
    print(i, scores[i])

# total and average of a list
total = 0
for s in scores:
    total = total + s
print("Mean:", total / len(scores))

# every seat in a 2D list: a loop inside a loop
for row in range(len(seats)):
    for col in range(len(seats[row])):
        print(row, col, seats[row][col])

A string is a sequence of characters, so it has indexes too, just like a list. A space counts as a character. So does punctuation.

A subroutine is a named chunk of code you can run whenever you need it. Scratch calls these "My Blocks". Python uses def.

def greet(name):
    print("Hello, " + name + "!")

greet("Ana")
greet("Leo")

def area(w, h):
    result = w * h
    return result

a = area(4, 3)
print(a + 1)

1. def defines the subroutine. Nothing runs yet. It's a recipe written down, not cooked.

2. w and h are parameters: placeholder names in the def line.

3. area(4, 3) calls it. 4 and 3 are arguments: the real values. They're copied into w and h, in order.

4. return ends the subroutine at once and sends a value back to where it was called.

A variable made inside a subroutine is local. It only exists while the subroutine runs, and only inside it. A variable made in the main program is global: it can be read everywhere.

1. Local is safer. Two subroutines can both use a variable called total without clashing. Each has its own.

2. Local saves memory. The local box is wiped as soon as the subroutine returns.

3. Globals are risky. Any part of the program could change them, so bugs are hard to trace. Pass values in as arguments and return results instead.

Validation checks input is sensible before the program uses it. It's the bouncer at the door: it doesn't know who you are, only whether you follow the rules.

def get_score():
    while True:                           # keep asking until it's valid
        text = input("Score (0-50): ")
        if text == "":
            print("Please type something.")     # presence check
        elif not text.isdigit():
            print("Whole numbers only.")        # type check
        elif int(text) > 50:
            print("0 to 50, please.")           # range check
        else:
            return int(text)

Defensive design and authentication

Defensive design means planning for users who make mistakes, and for users who attack. It has four parts: anticipate misuse, validate input, authenticate users, and keep the code maintainable (comments, good names, indentation, subroutines).

Authentication checks who you are: a password, a PIN, a fingerprint, or two-factor authentication. Validation comes first: there's no point checking a password that's blank.

Why does a lock-out matter so much? Without one, a computer can guess a billion passwords a second (brute force). With "3 tries, then wait 10 seconds", it gets 0.3 guesses a second.

By hand, for a 6-letter lowercase password, 3 tries then a 10-second lock. Press Next line.

1. Guesses per second: g = a ÷ s = 3 ÷ 10 = 0.3.

2. Possible passwords: C^L = 26⁶ = 26 × 26 × 26 × 26 × 26 × 26 = 308,915,776.

3. Time to try them all: T = 308,915,776 ÷ 0.3 = 1,029,719,253 seconds.

4. Seconds in a year ≈ 60 × 60 × 24 × 365.25 = 31,557,600. So T ≈ 1,029,719,253 ÷ 31,557,600 ≈ 32.6 years.

5. Without the lock-out, at 1,000,000,000 guesses a second: 308,915,776 ÷ 1,000,000,000 ≈ 0.3 seconds. Three lines of code turned a third of a second into 32 years.

Testing means trying to break your own program on purpose, before someone else does. You choose test data carefully, so a few tests cover every kind of input.

A test plan

A test plan is written before testing. It lists what you'll test, the data, and what should happen. Then you run each test and fill in what did happen.

Variables live in RAM, so they vanish when the program ends or the power goes off. To keep data, write it to a file in storage.

file = open("scores.txt", "a")
file.write("Ana,45\n")
file.close()

with open("scores.txt", "r") as file:
    for line in file:
        name, score = line.strip().split(",")
        print(name, "scored", int(score))

1. line.strip() removes the hidden \n at the end of each line.

2. .split(",") cuts the string at every comma and gives a list: "Ana,45" → ["Ana", "45"].

3. Everything read from a file is a string. Cast with int() before doing maths.

4. with open(…) as file: closes the file for you at the end of the block, even if there's an error. Prefer it.

There are three kinds of error. Each is found at a different time, in a different way.

try / except: catch a runtime error

while True:
    try:
        age = int(input("Age: "))    # might crash on "ten"
        break                         # it worked: leave the loop
    except ValueError:
        print("Please type digits, like 14.")
print("Next year you'll be", age + 1)

1. Python tries the lines under try:.

2. The user types ten. int("ten") can't work, so Python raises a ValueError.

3. Instead of crashing, it jumps straight to except ValueError: and prints the friendly message. The break is skipped.

4. The loop goes round. The user types 14. int("14") works, break leaves the loop.

5. Output: Next year you'll be 15. The program never crashed: it is robust.

The mistakes nearly everyone makes the first time. Read the left side, then the right.

Quick questions first. Then endless practice: a wrong answer shows you the working, step by step.