Content Area 2: Introduction to Programming

Rate each point. Be honest: 'Secure' means you could answer an exam question on it now without notes.

Every value in a program has a data type. The data type decides what the value can store and what you can do with it.

quantity = 3            # int
price = 4.75            # float
product = "Meal deal"   # str
in_stock = True         # bool
print(type(quantity), type(price), type(product), type(in_stock))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Integer

A whole number, positive, negative or zero. Python type int.

Float

A number with a decimal (fractional) part. Python type float.

String

A sequence of characters, written in quotes. Python type str.

Boolean

A value that is either True or False. Python type bool.

Variables and constants

Python has no built-in way to lock a constant. By convention, a name in CAPITALS tells other programmers not to change it.

MAX_ATTEMPTS = 3   # constant
attempts = 0       # variable
attempts = attempts + 1
print(f"Attempt {attempts} of {MAX_ATTEMPTS}")

Attempt 1 of 3

Data type conversion (casting)

input() always returns a string. To do maths with it, convert it first. Conversion is also needed to join numbers into strings.

age = int(input("Enter your age: "))
print("Next year you will be " + str(age + 1))

Enter your age: 17
Next year you will be 18

Scope: global and local variables

Scope is the part of the program where a variable can be used.

• A global variable is created outside any function. It can be read anywhere in the program.
• A local variable is created inside a function. It only exists while the function is running and cannot be used outside it.
• To change a global variable inside a function, Python needs the global keyword.

basket_total = 0            # global

def add_item(price):
    global basket_total
    discount = 0.1          # local: only exists inside add_item
    basket_total = basket_total + price * (1 - discount)

add_item(20)
add_item(10)
print(basket_total)

27.0

Variable

A named location in memory that stores a value which can change while the program runs.

Constant

A named value that does not change while the program runs. In Python, written in CAPITALS by convention.

Casting / type conversion

Changing a value from one data type to another, e.g. int("42").

Scope

The part of a program where a variable can be accessed.

Global variable

A variable declared outside any function, which can be read anywhere in the program.

Local variable

A variable declared inside a function. It only exists while that function runs.

List and dictionary operations (Appendix 2)

queue = ["Asha", "Ben", "Chloe"]
queue.append("Dev")          # add to end
queue.insert(0, "Ellie")     # add at index 0
queue.remove("Ben")          # remove by value
first = queue.pop(0)         # remove and return item at index 0
print(first, queue, len(queue))
print(queue.index("Chloe"), "Dev" in queue, "Ben" not in queue)
queue.sort()
print(queue)

Ellie ['Asha', 'Chloe', 'Dev'] 3
1 True True
['Asha', 'Chloe', 'Dev']

prices = {"latte": 3.20, "tea": 1.80}
prices["mocha"] = 3.50       # add a new key
prices["tea"] = 1.95         # update an existing key
for drink, price in prices.items():
    print(f"{drink}: £{price:.2f}")
print("cocoa" in prices)

latte: £3.20
tea: £1.95
mocha: £3.50
False

2D lists

A list can hold other lists, which works like a table. Use two indexes: [row][column].

seats = [["A1", "A2", "A3"],
         ["B1", "B2", "B3"]]
print(seats[1][2])
for row in seats:
    print(len(row), row[0])

B3
3 A1
3 B1

Worked example: debugging a data structure

This code should print the total of all marks. It crashes. Find and fix the error.

marks = [45, 67, 89, 72]
total = 0
for i in range(1, len(marks) + 1):
    total = total + marks[i]
print(total)

marks = [45, 67, 89, 72]
total = 0
for mark in marks:
    total = total + mark
print(total)

273

List

An ordered, changeable collection of items that can hold mixed data types and grow or shrink.

Array

An ordered collection of items that are all the same data type.

Dictionary

A collection of key–value pairs. Values are looked up by key rather than position.

Index

The position of an item in a list, array or string. Python starts counting at 0.

Arithmetic operators

Worked example: // and %

minutes = 135
hours = minutes // 60
left_over = minutes % 60
print(f"{hours} h {left_over} min")
eggs = 26
print("Full boxes:", eggs // 6, "Spare eggs:", eggs % 6)

2 h 15 min
Full boxes: 4 Spare eggs: 2

Relational operators

Relational operators compare two values and always give a Boolean result.

Boolean operators

Order of operations

Python follows BIDMAS: brackets, then **, then * / // %, then + -. Then relational operators, then not, and, or.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(10 - 4 / 2)
mark_a, mark_b = 60, 80
print(mark_a + mark_b / 2)      # logic error
print((mark_a + mark_b) / 2)    # correct average

14
20
8.0
100.0
70.0

Keyboard and screen

• input("prompt") displays the prompt, waits for the user to press Enter and returns what they typed as a string.
• print() outputs to the screen. Separate items with commas, join strings with +, or use an f-string.
• .format() and f-strings can format numbers: {price:.2f} shows 2 decimal places.

name = input("Name: ")
hours = float(input("Hours worked: "))
rate = 11.44
pay = hours * rate
print(f"{name} earned £{pay:.2f}")
print("{} earned £{:.2f}".format(name, pay))

Name: Sam
Hours worked: 16
Sam earned £183.04
Sam earned £183.04

Text files

scores = {"Asha": 18, "Ben": 12, "Chloe": 20}

f = open("scores.txt", "w")
for name, score in scores.items():
    f.write(name + "," + str(score) + "\n")
f.close()

f = open("scores.txt", "r")
for line in f.readlines():
    parts = line.strip().split(",")
    print(parts[0], "scored", int(parts[1]))
f.close()

Asha scored 18
Ben scored 12
Chloe scored 20

line.strip() removes the \n and spaces from each end. line.split(",") breaks the line into a list at every comma.

Selection: if / elif / else

mark = 64
if mark >= 70:
    grade = "Distinction"
elif mark >= 55:
    grade = "Merit"
elif mark >= 40:
    grade = "Pass"
else:
    grade = "Fail"
print(grade)

Merit

Conditions are checked from the top. The first True one runs and the rest are skipped. That is why the highest boundary goes first: if mark >= 40 came first, 64 would get a Pass.

Selection: match / case (Python 3.10+)

match compares one value against several possible patterns. It is tidier than a long elif chain when you are checking a single value for exact matches, such as a menu choice.

choice = "2"
match choice:
    case "1":
        print("View basket")
    case "2":
        print("Checkout")
    case "3" | "q":
        print("Quit")
    case _:
        print("Invalid option")

Checkout

case _: is the default and works like else. | means 'or'. match cannot do range checks like mark >= 70 without extra syntax, so use if for those.

Iteration

for i in range(1, 11, 3):
    print(i, end=" ")
print()
total = 0
count = 0
while total < 20:
    total = total + 7
    count = count + 1
print(total, count)

1 4 7 10
21 3

range(start, stop, step): stop is not included. range(5) gives 0, 1, 2, 3, 4.

Benefits and drawbacks of loops (2.6.5)

Worked example: trace table

A trace table records the value of each variable as the code runs, line by line. It is the best way to answer 'what is the output' questions. Draw your own before you check.

n = 5
result = 1
while n > 1:
    result = result * n
    n = n - 2
print(result)

15

Sequence

Instructions run one after another in the order written.

Selection

Choosing which code to run based on a condition (if, elif, else, match/case).

Iteration

Repeating a block of code (a loop).

Count-controlled loop

A loop that repeats a set number of times (for).

Condition-controlled loop

A loop that repeats while a condition is True (while).

def calculate_vat(price, rate=0.2):      # function: returns a value
    return round(price * rate, 2)

def print_receipt(item, price):          # procedure: no return value
    vat = calculate_vat(price)
    print(f"{item:<10} £{price:>6.2f}  VAT £{vat:.2f}")

print_receipt("Keyboard", 24.99)
print_receipt("Mouse", 9.5)

Keyboard   £ 24.99  VAT £5.00
Mouse      £  9.50  VAT £1.90

price and rate are parameters. 24.99 is an argument: the actual value passed in. rate=0.2 is a default value used if no argument is given.

Where functions and procedures come from (2.7.3)

import math
import random

print(math.floor(7.8), math.ceil(7.2), math.trunc(-7.8))
print(math.sqrt(81), math.pow(2, 5), round(math.pi, 3))
roll = random.randint(1, 6)
print(1 <= roll <= 6)
print(ord("A"), chr(66), max([4, 9, 2]), min(4, 9, 2))

7 8 -7
9.0 32.0 3.142
True
65 B 9 2

Benefits and drawbacks of pre-written code (2.7.4)

String handling methods (Appendix 2)

email = "  Sam.Jones@Example.co.uk  "
email = email.strip().lower()
print(email)
print(email.find("@"), email.index("."), email.count("o"))
user, domain = email.split("@")
print(user, domain, len(user))
print("abc123".isalnum(), "abc".isalpha())
print("2024".isdigit(), "ABC".isupper())
print(email.replace("example", "sample"))

sam.jones@example.co.uk
9 3 2
sam.jones example.co.uk 9
True True
True True
sam.jones@sample.co.uk

Function

A named subroutine that may take parameters and must return a value.

Procedure

A named subroutine that may take parameters and does not return a value.

Parameter

A variable listed in a subroutine definition that receives a value when the subroutine is called.

Argument

The actual value passed to a subroutine when it is called.

Library

A collection of pre-written code that can be imported, e.g. math, random.

Validation is an automatic check that input data is sensible and follows set rules before it is accepted. It reduces errors and stops a program crashing on bad data. It cannot check that data is correct: a valid date of birth may still be the wrong one.

def get_quantity():
    while True:
        entry = input("Quantity (1-10): ")
        if entry == "":                        # presence check
            print("Error: quantity cannot be blank.")
        elif not entry.isdigit():              # type check
            print("Error: enter a whole number.")
        elif not 1 <= int(entry) <= 10:        # range check
            print("Error: quantity must be between 1 and 10.")
        else:
            return int(entry)

qty = get_quantity()
print("Accepted:", qty)

Quantity (1-10):
Error: quantity cannot be blank.
Quantity (1-10): two
Error: enter a whole number.
Quantity (1-10): 15
Error: quantity must be between 1 and 10.
Quantity (1-10): 4
Accepted: 4

def valid_password(pw):
    return len(pw) >= 8                        # length check

def valid_email(email):                        # simple format check
    if email.count("@") != 1:
        return False
    user, domain = email.split("@")
    return len(user) > 0 and "." in domain

print(valid_password("letmein"))
print(valid_email("ali@wakefield.ac.uk"))
print(valid_email("ali.wakefield"))

False
True
False

Check digit worked example: ISBN-13

Multiply the 13 digits alternately by 1 and 3 and add the results. If the total divides exactly by 10, the number is valid. A single mistyped digit or two swapped digits will usually fail.

def valid_isbn13(isbn):
    if len(isbn) != 13 or not isbn.isdigit():
        return False
    total = 0
    for i in range(13):
        weight = 1 if i % 2 == 0 else 3
        total = total + int(isbn[i]) * weight
    return total % 10 == 0

print(valid_isbn13("9780306406157"))
print(valid_isbn13("9780306406158"))

True
False

Try it: ISBN-13 checker

Try changing one digit, or swapping two neighbouring digits.

Validation

Automatic checks that input data is sensible and follows rules before it is accepted. It does not check data is correct.

Check digit

An extra digit calculated from the other digits in a number, used to detect input errors.

Order of actions and operations (2.9.1–2.9.2, 2.9.4)

• Actions must happen in a logical order: get input, validate it, process it, output the result. You cannot calculate a total before reading the prices.
• Initialise variables before a loop. Setting total = 0 inside the loop resets it every time.
• Use brackets so calculations follow the order you intend. This keeps outputs accurate and avoids logic errors.
• Check for zero before dividing: if count > 0: average = total / count. This avoids a ZeroDivisionError.
• For efficiency, do work once rather than inside a loop. Calculate len(items) once before the loop; put the most likely condition first in an if chain; stop a search as soon as the item is found.

Choosing data structures for efficiency (2.9.3)

Naming conventions (2.9.5)

Code style and readability (2.9.6)

• Naming conventions: consistent names let any developer guess what a variable holds.
• White space: blank lines between functions, spaces around operators (x = a + b), and consistent indentation make structure obvious. In Python, indentation is required, not optional.
• Maximum line length: PEP 8 suggests 79 characters. Short lines can be read without scrolling sideways and are easier to compare side by side.

Hard to read:

def a(b,c):
    d=b*c
    if d>100:d=d*0.9
    return d
print(a(12,10))

108.0

Same logic, readable:

BULK_DISCOUNT = 0.9
BULK_THRESHOLD = 100


def order_cost(unit_price, quantity):
    cost = unit_price * quantity
    if cost > BULK_THRESHOLD:
        cost = cost * BULK_DISCOUNT
    return cost


print(order_cost(12, 10))

108.0

Judging an algorithm (2.9.7)

When asked to judge the suitability of an algorithm or program, comment on each of these:

camelCase

Naming style where words are joined and each word after the first starts with a capital: totalPrice.

snake_case

Naming style where words are lower case and joined with underscores: total_price. Recommended for Python variables.

Characteristics of robust code (2.10.1)

• Handles unexpected inputs: validates input and re-prompts instead of crashing. Letters typed into a number field are rejected.
• Handles unexpected terminations: uses try/except to catch runtime errors (missing file, network down, divide by zero) and closes files or saves data safely.
• Produces specific and meaningful error messages: 'Quantity must be between 1 and 10' tells the user what to fix. 'Error' does not.

def read_total(filename):
    try:
        with open(filename, "r") as f:
            values = [float(line.strip()) for line in f]
        return sum(values)
    except FileNotFoundError:
        print(f"Error: '{filename}' was not found. Check the file name.")
    except ValueError:
        print(f"Error: '{filename}' contains a line that is not a number.")
    return None

with open("sales.txt", "w") as f:
    f.write("12.50\n8.25\nten\n")

print(read_total("sale.txt"))
print(read_total("sales.txt"))

Error: 'sale.txt' was not found. Check the file name.
None
Error: 'sales.txt' contains a line that is not a number.
None

Types of error

Debugging (2.10.2–2.10.5)

Debugging is locating errors and then correcting them. It is used during development, after a test fails and when users report faults. Debugging makes code robust because each error found and fixed is one less way for the program to crash or give wrong results.

Worked example: locate and correct

This program should count how many students passed (40 or more) and print the pass rate. It contains three errors. Find them before you check.

marks = [38, 40, 72, 55, 19]
for mark in marks:
    passed = 0
    if mark > 40:
        passed = passed + 1
rate = passed / len(marks) * 100
print("Pass rate: " + rate + "%")

marks = [38, 40, 72, 55, 19]
passed = 0
for mark in marks:
    if mark >= 40:
        passed = passed + 1
rate = passed / len(marks) * 100
print("Pass rate: " + str(rate) + "%")

Pass rate: 60.0%

Robust code

Code that handles unexpected inputs and terminations and gives specific, meaningful error messages.

Debugging

Locating and correcting errors in code.

Syntax error

Code that breaks the rules of the language, so it cannot run.

Runtime error

An error that happens while the program is running, causing it to crash, e.g. dividing by zero.

Logic error

The program runs but gives the wrong result.

Exception

An error object raised at runtime. Can be caught with try/except.

You need to know how each algorithm works, be able to trace it, and judge when to use it. Big O notation is not required: compare using logical reasoning about comparisons, time and memory.

Try it: algorithm stepper

Pick an algorithm, type a list, then press Step to watch it work one comparison at a time.

Yellow = being compared · Green = in its final place / found · Faded = discarded

Linear search

1. Start at the first item.
2. Compare it with the target.
3. If it matches, stop and return the position.
4. Otherwise move to the next item.
5. If you reach the end without a match, the item is not there.

def linear_search(items, target):
    for i in range(len(items)):
        if items[i] == target:
            return i
    return -1

print(linear_search(["Leeds", "York", "Hull", "Wakefield"], "Hull"))
print(linear_search(["Leeds", "York"], "Bradford"))

2
-1

Binary search

The list must be sorted first.

1. Find the middle item.
2. If it is the target, stop.
3. If the target is smaller, discard the middle item and everything above it.
4. If the target is larger, discard the middle item and everything below it.
5. Repeat on the half that is left until the target is found or nothing is left.

def binary_search(items, target):
    low = 0
    high = len(items) - 1
    while low <= high:
        mid = (low + high) // 2
        if items[mid] == target:
            return mid
        elif target < items[mid]:
            high = mid - 1
        else:
            low = mid + 1
    return -1

numbers = [3, 8, 12, 19, 25, 31, 40, 47, 52]
print(binary_search(numbers, 40))

6

Linear search would have needed 7 comparisons to find 40. Binary search needed 2.

Bubble sort

1. Compare the first two items. If they are in the wrong order, swap them.
2. Move along one place and compare the next pair. Repeat to the end of the list: this is one pass.
3. After each pass the largest unsorted item has 'bubbled' to its correct place at the end.
4. Repeat passes until a whole pass makes no swaps.

def bubble_sort(items):
    n = len(items)
    swapped = True
    while swapped:
        swapped = False
        for i in range(n - 1):
            if items[i] > items[i + 1]:
                items[i], items[i + 1] = items[i + 1], items[i]
                swapped = True
        n = n - 1
    return items

print(bubble_sort([5, 1, 4, 2, 8]))

[1, 2, 4, 5, 8]

Insertion sort

1. Treat the first item as a sorted list of one.
2. Take the next item.
3. Compare it with items in the sorted part, moving larger items one place right, until you find where it belongs.
4. Insert it. Repeat until every item has been inserted.

def insertion_sort(items):
    for i in range(1, len(items)):
        current = items[i]
        j = i - 1
        while j >= 0 and items[j] > current:
            items[j + 1] = items[j]
            j = j - 1
        items[j + 1] = current
    return items

print(insertion_sort([7, 3, 9, 1, 5]))

[1, 3, 5, 7, 9]

Merge sort

1. Split the list in half, then split each half again, until every list has one item (a list of one is sorted).
2. Merge pairs of lists back together: compare the front item of each list and take the smaller one each time.
3. Keep merging until there is one sorted list.

def merge_sort(items):
    if len(items) <= 1:
        return items
    mid = len(items) // 2
    left = merge_sort(items[:mid])
    right = merge_sort(items[mid:])
    merged = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            merged.append(left[i])
            i = i + 1
        else:
            merged.append(right[j])
            j = j + 1
    merged = merged + left[i:] + right[j:]
    return merged

print(merge_sort([38, 27, 43, 3, 9, 82, 10]))

[3, 9, 10, 27, 38, 43, 82]

Comparing algorithms (2.11.3–2.11.5)

Metrics: memory space used, execution time, and number of comparisons. The table assumes a list of n items.

Linear search

Checks each item in turn from the start until the target is found or the list ends.

Binary search

Repeatedly checks the middle item of a sorted list and discards the half that cannot contain the target.

Bubble sort

Compares adjacent pairs and swaps them if they are in the wrong order, repeating passes until no swaps are made.

Insertion sort

Builds a sorted section one item at a time by inserting each item into its correct position.

Merge sort

Splits a list into single items, then merges them back together in order.

Why test components separately (2.12.1)

Each part of a solution is tested on its own before everything is put together. Faults are easier and cheaper to find and fix in a small part than in the finished system, where it is hard to tell which part caused the problem.

Testing methods (2.12.2)

Automation (2.12.3)

A simple test script:

def is_valid_age(age):
    return 16 <= age <= 99

tests = [(15, False), (16, True), (50, True), (99, True), (100, False)]
for value, expected in tests:
    actual = is_valid_age(value)
    result = "PASS" if actual == expected else "FAIL"
    print(value, "expected", expected, "got", actual, result)

15 expected False got False PASS
16 expected True got True PASS
50 expected True got True PASS
99 expected True got True PASS
100 expected False got False PASS

Test data (2.12.4.1–2.12.4.2)

Example: a cinema app accepts a number of tickets from 1 to 8.

Quick sort: what type of test data is it?

The cinema app accepts 1 to 8 tickets. Choose the type for each item.

Test plan (2.12.4.3)

A test plan is written before testing and completed during testing. Its steps are: identify the tests; describe the purpose of each; identify the test data; describe the expected results; record the actual results.

Test plan

A document listing the tests to run, their purpose, the test data, expected results and actual results.

Valid test data

Data that should be accepted and processed normally.

Invalid test data

Data of the correct type that should be rejected because it breaks a rule, e.g. age = 150.

Boundary test data

Data at the edge of what is allowed, and just outside it, e.g. 0, 1, 100, 101 for a 1–100 range.

Erroneous test data

Data of the wrong type that should be rejected, e.g. "ten" when a number is expected.

Unit testing

Testing one component (e.g. a function) on its own.

Integration testing

Testing that components work correctly together.

Regression testing

Re-running earlier tests after a change to check nothing that worked before is now broken.

Open box testing

Testing with knowledge of the code, checking every path runs correctly (also called white box).

Closed box testing

Testing inputs and outputs without looking at the code (also called black box).

Flashcards

Every Quick recall definition on this page. Click the card to flip it; use the arrow keys to move.

Random questions on CA2 from the course question bank. Pick a topic or question type, answer in your head or on paper, then check. Your score is saved on this device.

Allow about 1 hour 45 minutes. Questions get harder as you go.

total = 0
for i in range(2, 9, 3):
    total = total + i
    print(i, total)

while True:
    password = input("Enter a password: ")
    has_digit = False
    for ch in password:
        if ch.isdigit():
            has_digit = True
    if len(password) < 8:
        print("Error: password must be at least 8 characters.")
    elif not has_digit:
        print("Error: password must contain at least one digit.")
    else:
        print("Password set")
        break

Enter a password: cat
Error: password must be at least 8 characters.
Enter a password: elephants
Error: password must contain at least one digit.
Enter a password: elephant5
Password set

f = open("temps.txt", "w")
total = 0
count = 0
for line in f.readlines():
    total = total + line.strip()
    count = count + 1
f.close()
print("Average:", total // count)

def count_vowels(word):
    count = 0
    for letter in word.lower():
        if letter in "aeiou":
            count = count + 1
    return count

print(count_vowels("Wakefield"))

4

My corrections: what I need to go back over