Loading…
Free A-Level Computer Science guide
For 9618 examinations in 2027–2029, file skills connect AS text-file work with A Level file organisation, random access and exception handling. Build the file model before choosing the open mode.
Content owner: Michael Print · Written for A-Level learners · Checked against official specifications
READ obtains existing data; WRITE creates/replaces contents; APPEND adds after existing contents. EOF means no further data remains; a blank line is still a record of text. Close files reliably after use.
Serial organisation follows arrival order, sequential organisation sorts records by a key, and random organisation locates records using a key-to-location rule. Access method is separate: reading in order is sequential access; moving to a known record position is direct access.
Cambridge International 9618 · 9618 (2027–2029): 10.3, 13.2, 20.2; Paper 4 practical scope
Useful foundations
By the end, you should be able to
The baseline is 2027–2029 syllabus version 2. The checked 2026 version 2 has the same teaching requirements here; use the entry year’s own materials.
Paper 4 assesses practical application of sections 19–20, except low-level/declarative programming, using Python, Java or .NET Visual Basic in console mode. Tasks may request programs or program elements; submit their specified code and testing evidence.
General OCR project guidance does not replace Cambridge’s task instructions. Follow the exact filenames, record formats and evidence requirements supplied with each practical task.
Cambridge’s official clarification says supplied source files are text, rather than binary. Candidates are expected to write a hashing algorithm and access another data structure to simulate random files.
This practical example loads text into an array-backed hash table, performs keyed access and saves text for reloading. Using only a built-in dictionary would conceal the hashing algorithm being practised.
The later binary example is a theory extension for direct-access mechanics. It is separate from Cambridge’s practical text/ADT convention and from assessed learner work.
Load text records
Read key,quantity lines from the supplied text file.
Build the hash table
Calculate each key’s slot and resolve collisions using bounded linear probing.
Look up and update
Use the same probe sequence; confirm the stored key before accessing its quantity.
Save occupied records
Write the changed records to text. An in-memory change alone does not persist.
Reload next time
Rebuild the table by hashing the saved records; text line order is not a physical record address.
Cambridge pseudocode uses OPENFILE ... FOR READ/WRITE/APPEND, READFILE, WRITEFILE and CLOSEFILE. EOF tests whether another line remains. Python r/w/a provide the corresponding basic text roles.
State the encoding where appropriate. Python’s with block closes its file even if an exception exits the block. Cambridge pseudocode still needs its explicit closing operation.
Python iteration ends at EOF without an extra invalid read. readline() returns an empty string at EOF, but a blank text line normally returns a newline character.
Cambridge READFILE represents the line’s text without Python’s newline handling. Do not import Python’s blank/EOF representation into pseudocode. Validate record structure before converting fields; silently skipping malformed lines can hide corruption.
Serial organisation keeps arrival order; a serial log can be read from start to finish. Sequential organisation sorts records by key, supporting sorted searches and merges. Random organisation maps a key to a location, often by hashing.
Access is a separate choice. Sequential access reads records in order; direct access seeks a known position without reading every earlier record. An index may supply direct positions even for an otherwise ordered file.
The deterministic hash key MOD 5 can collide. With five slots 0–4, 12 uses slot 2, 17 probes from 2 to 3, and 9 uses 4. Lookup 17 checks slots 2 then 3 and compares stored keys.
Linear probing wraps around and needs a bounded probe count when full. Deletion needs a tombstone or another collision-aware rule: making slot 2 simply empty could incorrectly stop a search for 17.
Our list supplies fixed-capacity slots; modulo and bounded probing implement hashing. Put inserts or updates a key. Keys and quantities are non-negative integers; a repeated input key replaces its earlier quantity.
Insertion into a full table raises OverflowError. None marks an unused slot. No deletion is implemented, so lookup may safely stop at None; insertion and lookup follow the same probe sequence.
Saving writes occupied records as text. Reloading hashes them again, so their slot arrangement need not match saved line order. A keyed lookup avoids re-reading every earlier text line on each request.
Cambridge random-file pseudocode uses FOR RANDOM, SEEK, GETRECORD and PUTRECORD. PUTRECORD replaces data at the chosen pointer. State an exercise’s record-number convention; a record address is not automatically a Python byte offset.
In the binary theory example, slots are zero-based and records are eight bytes each. Slot s begins at byte 8×s. This demonstrates physical direct access; the text/ADT simulation follows the practical clarification.
The struct format >II stores key and quantity as two four-byte unsigned integers in fixed byte order. r+b opens an existing binary file for updating; wb creates the demonstration file and truncates existing contents.
Variable-length UTF-8 lines cannot safely use this fixed-offset formula. The demonstration uses a temporary folder, protecting a learner’s existing files from overwriting.
An exception interrupts normal execution. Missing files can raise FileNotFoundError; non-numeric conversion can raise ValueError; failed device/file operations can raise an OSError subtype.
Catch failures the program can explain or recover from; otherwise let them surface. Catching every exception and returning zero falsely presents failed processing as a valid total.
Validation checks a field before use. Exception handling deals with failures during an attempted operation, including conditions changing between check and use. A partial read must not count as a complete fixed record.
The examples reject malformed records and retain the filename and line number for the caller. An interface can explain the failure without exposing unrelated private data.
Worked example
from pathlib import Path
from tempfile import TemporaryDirectory
def total_quantity(path):
total = 0
with path.open("r", encoding="utf-8") as source:
for number, line in enumerate(source, start=1):
context = f"{path.name}: line {number}"
fields = line.strip().split(",")
if len(fields) != 2 or not fields[0]:
raise ValueError(f"{context}: invalid record")
try:
quantity = int(fields[1])
except ValueError as error:
raise ValueError(f"{context}: quantity must be an integer") from error
if quantity < 0:
raise ValueError(f"{context}: negative quantity")
total += quantity
return total
with TemporaryDirectory() as folder:
path = Path(folder) / "items.txt"
with path.open("w", encoding="utf-8") as target:
target.write("A,4\nB,3\n")
print(total_quantity(path))
with path.open("a", encoding="utf-8") as target:
target.write("C,5\n")
print(total_quantity(path))
path.write_text("", encoding="utf-8")
print("empty:", total_quantity(path))
path.write_text("A,no\n", encoding="utf-8")
try:
total_quantity(path)
except ValueError:
print("invalid record caught")
try:
total_quantity(Path(folder) / "missing.txt")
except FileNotFoundError:
print("missing file caught")Worked example
| Operation | Probe slots | Result |
|---|---|---|
| Insert 12 | 2 | Slot 2: (12,4) |
| Insert 17 | 2,3 | Slot 3: (17,3) |
| Insert 9 | 4 | Slot 4: (9,5) |
| Find 22 | 2,3,4,0 | Missing: slot 0 is unused |
| Update 17 | 2,3 | Slot 3: (17,8) |
from pathlib import Path
from tempfile import TemporaryDirectory
def probe_slots(table, key):
if not table or type(key) is not int or key < 0:
raise ValueError("Expected a non-empty table and non-negative integer key")
start = key % len(table)
for offset in range(len(table)):
yield (start + offset) % len(table)
def put_record(table, key, quantity):
if type(quantity) is not int or quantity < 0:
raise ValueError("Expected a non-negative integer quantity")
for slot in probe_slots(table, key):
if table[slot] is None or table[slot][0] == key:
table[slot] = (key, quantity)
return
raise OverflowError("Hash table is full")
def get_record(table, key):
for slot in probe_slots(table, key):
if table[slot] is None:
return None
if table[slot][0] == key:
return table[slot]
return None
def load_records(path, capacity):
if type(capacity) is not int or capacity <= 0:
raise ValueError("Expected a positive integer capacity")
table = [None] * capacity
with path.open("r", encoding="utf-8") as source:
for number, line in enumerate(source, start=1):
fields = line.strip().split(",")
context = f"{path.name}: line {number}"
if len(fields) != 2:
raise ValueError(f"{context}: expected key,quantity")
try:
key, quantity = (int(field) for field in fields)
put_record(table, key, quantity)
except (ValueError, OverflowError) as error:
raise type(error)(f"{context}: {error}") from error
return table
def save_records(path, table):
with path.open("w", encoding="utf-8") as target:
for record in table:
if record is not None:
key, quantity = record
target.write(f"{key},{quantity}\n")
with TemporaryDirectory() as folder:
path = Path(folder) / "stock.txt"
path.write_text("12,4\n17,3\n9,5\n", encoding="utf-8")
table = load_records(path, 5)
print("slots:", table)
print("find 17:", get_record(table, 17))
print("missing 22:", get_record(table, 22))
put_record(table, 17, 8)
save_records(path, table)
restored = load_records(path, 5)
print("reloaded 17:", get_record(restored, 17))Worked example
from pathlib import Path
from tempfile import TemporaryDirectory
import struct
record = struct.Struct(">II")
with TemporaryDirectory() as folder:
path = Path(folder) / "items.dat"
with path.open("wb") as target:
target.write(record.pack(101, 4))
target.write(record.pack(102, 7))
with path.open("r+b") as target:
target.seek(record.size)
data = target.read(record.size)
if len(data) != record.size:
raise ValueError("Incomplete record")
key, quantity = record.unpack(data)
if key != 102:
raise ValueError("Unexpected key")
target.seek(record.size)
target.write(record.pack(key, quantity + 2))
with path.open("rb") as source:
source.seek(record.size)
print(record.unpack(source.read(record.size)))6 original questions total 23 marks. Attempt each before opening the independently written indicative marking guidance.
A file contains two records. Explain the effects of READ, WRITE and APPEND, and distinguish a blank line from EOF.
Indicative answer
Five empty random-file slots numbered 0–4 use key MOD 5 and linear probing with wrap-around. Insert keys 12, 17 and 22 in that order, then explain why deleting 12 needs care.
Indicative answer
A Paper 4 practice task supplies text records 12,4; 17,3; 9,5 and asks for simulated random access using five slots and key MOD 5 with linear probing. Explain loading, trace lookup 17, and explain how changing its quantity to 8 can survive a program restart.
Indicative answer
An eight-byte record file uses zero-based slots. Give the byte address of slot 3 and explain why a second seek is needed before rewriting a just-read record.
Indicative answer
A programmer catches every exception and returns zero from total_quantity. Explain why this is unsafe and suggest a better approach.
Indicative answer
Design four meaningful tests for the text-file function described below, stating expected results.
total_quantity(path) reads a UTF-8 file with one item-code,quantity record per line and adds every quantity to a total initialised to 0. Example input records are A,4 and B,3.
Each record must have exactly one comma, a non-empty item code and an integer quantity at least 0. Invalid records raise ValueError; a missing file raises FileNotFoundError. An APPEND operation can add another record while preserving earlier lines.
Indicative answer
This guide addresses Cambridge International 9618 9618 (2027–2029): 10.3, 13.2, 20.2; Paper 4 practical scope. Check your examination year and the complete specification for the assessment scope.
These are independently written explanations and practice questions. CompSciTutoring.co.uk is not affiliated with or endorsed by an examination board. The marking guidance is indicative; always check the syllabus for your examination year.
Found an error? Email a correction.
Use the free examples first, then explore one-to-one tuition if guided practice would help.