Python Programming

Structuring a program

Subroutines

A subroutine is a named block of code you can call whenever you need it.

def get_valid_mark(prompt):
    # Keep asking until the user enters a mark between 0 and 100
    while True:
        entry = input(prompt)
        if entry.isdigit() and 0 <= int(entry) <= 100:
            return int(entry)
        print("Please enter a whole number between 0 and 100.")

def grade_for(mark):
    if mark >= 70:
        return "Distinction"
    elif mark >= 50:
        return "Pass"
    else:
        return "Fail"

mark = get_valid_mark("Enter the mark: ")
print("Grade:", grade_for(mark))

Notice how the main program at the bottom reads almost like English. That is what good structure buys you.

• A function returns a value using return
• A procedure just does something and returns nothing

Local and global variables

A local variable exists only inside the subroutine that created it. A global variable exists everywhere.

Local is almost always better, because nothing else in the program can change it by accident.

def add_tax(amount):
    tax = amount * 0.2      # local, disappears when the function ends
    return amount + tax

Lists, 2D lists and dictionaries

Working with lists

scores = [45, 78, 12, 90, 33]

print(sum(scores), max(scores), min(scores), len(scores))
print(sorted(scores))          # a sorted copy
scores.sort()                  # sorts in place
scores.append(60)
scores.insert(0, 5)            # insert at the start
scores.remove(12)              # remove the value 12
print(scores.index(90))        # position of 90
print(90 in scores)            # True or False

2D lists

A 2D list is a list of lists, forming a grid.

board = [["X", "O", "X"],
         ["O", "X", "O"],
         ["X", "O", "X"]]

print(board[1][2])       # row 1, column 2, which is "O"

for row in board:
    for cell in row:
        print(cell, end=" ")
    print()

Dictionaries

A dictionary stores pairs of keys and values, which is far more readable than remembering that index 3 was the score.

student = {"name": "Aisha", "year": 9, "score": 82}

print(student["name"])          # Aisha
student["score"] = 90           # change a value
student["house"] = "Blue"       # add a new pair

for key in student:
    print(key, "=", student[key])

Files and building a real program

Reading and writing files

# Write, which erases anything already in the file
with open("scores.txt", "w") as file:
    file.write("Aisha,82
")
    file.write("Ben,64
")

# Append, which adds without deleting
with open("scores.txt", "a") as file:
    file.write("Chloe,91
")

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

Using with open(...) closes the file automatically, even if something goes wrong.

Putting it together

def load_scores(filename):
    scores = {}
    try:
        with open(filename, "r") as file:
            for line in file:
                name, value = line.strip().split(",")
                scores[name] = int(value)
    except FileNotFoundError:
        print("No score file yet, starting fresh.")
    return scores

def save_scores(filename, scores):
    with open(filename, "w") as file:
        for name in scores:
            file.write(name + "," + str(scores[name]) + "
")

def show_top(scores):
    if len(scores) == 0:
        print("No scores recorded.")
        return
    best = max(scores, key=scores.get)
    print("Top score:", best, "with", scores[best])

scores = load_scores("scores.txt")
scores["Dev"] = 77
show_top(scores)
save_scores("scores.txt", scores)

This program has four clear jobs, each in its own subroutine, and it handles the case where the file does not exist yet. That is the difference between code that works on your machine and code that works.

Key terms you must be able to define

Subroutine

A named block of code that performs a task and can be called from anywhere in a program.

Function

A subroutine that returns a value.

Procedure

A subroutine that performs a task without returning a value.

Parameter

A value passed into a subroutine so it can do its work.

Local variable

A variable that exists only inside the subroutine where it was created.

Global variable

A variable available throughout the whole program.

2D list

A list of lists, forming a grid accessed by row and column.

Dictionary

A data structure storing pairs of keys and values.

Append mode

Opening a file so new data is added to the end without erasing existing content.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

The top level in Year 9 Python is about writing programs that survive contact with a real user.

Break the program into subroutines before you start typing. If you can name four jobs the program has to do, you have four subroutines and the code almost writes itself.

Handle the awkward cases. What if the file does not exist? What if the list is empty? What if the user types letters? A program that only works when everything goes right is not finished.

Comment why, not what. count = count + 1 # add one to count is useless. # skip the header row is worth having.

• Write a program using at least three subroutines with parameters and return values
• Read from and write to a file, choosing the correct mode
• Use a 2D list to represent a grid and loop through it correctly
• Validate every piece of input before the program uses it

Mistakes that cost marks here