Lists

A list in Python is the practical version of an array in Cambridge pseudocode. You will use lists every time a question asks you to store a collection of items — names, marks, temperatures, queue contents — and process them one by one.

# A list of integers
numbers = [10, 20, 30, 40, 50]

# Mixed types are allowed (rare in Paper 4 but legal)
mixed = [5, "hello", 3.14, True]

# An empty list — items added later
empty = []

# Fixed size of 10, pre-filled with zeros
scores = [0] * 10

# Fixed size of 20, pre-filled with empty strings
queueData = ["" for i in range(20)]

Python indexing starts at 0 for the first item. Negative indices count from the end — -1 is the last item, -2 the second-to-last. Lists are mutable: you can replace, add or remove items.

numbers = [10, 20, 30, 40, 50]

print(numbers[0])   # 10  → first
print(numbers[2])   # 30  → third
print(numbers[-1])  # 50  → last
print(numbers[-2])  # 40  → second-to-last

# Replace an item (lists are mutable)
numbers[1] = 25
print(numbers)      # [10, 25, 30, 40, 50]

fruits = ["apple", "banana"]
fruits.append("mango")      # end → ["apple","banana","mango"]
fruits.insert(1, "orange")  # idx 1 → ["apple","orange","banana","mango"]

fruits.remove("orange")  # first match
last = fruits.pop()       # remove+return last (stack pop)
print(len(fruits))        # number of items

Almost every Paper 4 list question needs you to visit every element. That visiting process is called traversal, and there are exactly two ways to do it in Python — you need both.

numbers = [10, 20, 30, 40, 50]
for num in numbers:
    print(num)
# num is each list item in turn.
# Use when you do NOT need the index.

numbers = [10, 20, 30, 40, 50]
for i in range(len(numbers)):
    print("Item at index", i, "is", numbers[i])
# range(len(...)) gives 0, 1, 2, 3, 4 —
# every valid index. Use to modify items
# (numbers[i] = ...) or report positions.

"How many?" and "what is the total?" are the two most common Paper 4 sub-questions. Both use the accumulator pattern: a variable that starts at zero before the loop, gets updated inside the loop, and is printed after the loop.

marks = [56, 78, 45, 90, 33]
total = 0                  # BEFORE
for m in marks:
    total = total + m      # INSIDE
print("Total:", total)     # AFTER

marks = [56, 78, 45, 90, 33]
passes = 0
for m in marks:
    if m >= 50:
        passes = passes + 1
print("Passes:", passes)

Finding the highest mark, the coldest temperature, or the average speed are stock Paper 4 questions. To find a max or min you cannot start the tracker at 0 — if all the values are negative, the answer would wrongly come out as 0. Start at the first element instead.

# Max, min AND average in ONE traversal
values = [12, 45, 7, 89, 3, 22]
maxValue = values[0]   # start with the first element
minValue = values[0]
total = 0
for v in values:
    if v > maxValue:
        maxValue = v
    if v < minValue:
        minValue = v
    total = total + v
average = total / len(values)
print("Max:", maxValue)
print("Min:", minValue)
print("Average:", round(average, 2))

Linear search is a guaranteed Paper 4 question type. The 9618 syllabus says you must write the algorithm — you cannot just use Python's in operator.

The found-flag pattern

items = [3, 8, 6, 12, 9]
target = 6

found = False       # assume not found
position = -1       # sentinel: "no valid position"
for i in range(len(items)):
    if items[i] == target:
        found = True
        position = i
        break         # stop on first match

if found:
    print("Found at index", position)
else:
    print("Not found")

• found starts False — we assume not found until proven otherwise.
• position = -1 is a sentinel meaning "no valid position" (list indices are never negative).
• break exits as soon as the target is found — without it, a duplicate target would overwrite position.

Frequency count (conditional counter)

nums = [4, 1, 4, 6, 4, 7, 2]
target = 4
count = 0
for n in nums:
    if n == target:
        count = count + 1
print("Frequency of", target, ":", count)
# Output: Frequency of 4 : 3

Building a duplicate-free copy of a list is the first algorithm on this page that uses a nested loop: an outer loop over the original list, and an inner loop over the unique list being built.

original = [1, 2, 2, 3, 4, 4, 1]
unique = []
for item in original:
    # Manual "is it already there?" check
    alreadyIn = False
    for u in unique:
        if u == item:
            alreadyIn = True
            break
    if not alreadyIn:
        unique.append(item)
print("Unique:", unique)
# Output: Unique: [1, 2, 3, 4]

Every sorting algorithm in Paper 4 — bubble sort, insertion sort — is built on top of swapping two elements. To swap safely you need a temporary variable to hold one value while the other is overwritten.

values = [1, 2, 3, 4, 5]
temp = values[0]          # 1. SAVE the first value
values[0] = values[-1]    # 2. OVERWRITE first with last
values[-1] = temp         # 3. RESTORE saved value into last
print(values)             # [5, 2, 3, 4, 1]

These tasks combine the skills from 4.1–4.8 into compound questions you will meet in the real Paper 4.

Fifteen exam-style tasks. Click Hint for bullet-point guidance, then Help to reveal a worked Python solution.