File processing – IB Computer Science exam questions with mark scheme

1Hard6 marks

A text file scores.txt stores one integer test score on each line, for example:

60
75
90

Write a Python function average_score(filename) that:

returns the mean of all the scores in the file;
returns 0 if the file contains no scores;
returns None if the file does not exist.

[6]

Opens the file for reading (using open, preferably with with so it is closed)(1)
Reads the file line by line (or all lines) with a loop (allow a list comprehension over the file or over f.read().split())(1)
Converts each line to an integer using int() (allow with or without .strip(), since int() ignores surrounding whitespace and the newline)(1)
Accumulates the total and the number of scores (allow building a list of the scores and using sum() and len())(1)
Avoids division by zero: returns 0 when there are no scores, otherwise returns total ÷ count(1)
Uses try/except FileNotFoundError (or equivalent check) to return None for a missing file(1)

Answer:

def average_score(filename):
    try:
        with open(filename, "r") as f:
            total = 0
            count = 0
            for line in f:
                line = line.strip()
                if line != "":
                    total += int(line)
                    count += 1
    except FileNotFoundError:
        return None
    if count == 0:
        return 0
    return total / count

Examiner tip: Check for an empty file before dividing, otherwise total / count raises ZeroDivisionError; int() copes with the trailing newline on its own.

2Core5 marks

A program opens a text file using Python's open() function.

(a) For each of the modes "r", "w" and "a", state what happens when the program opens a file that already exists and contains data. [3]

(b) State what happens when a file that does not exist is opened in "r" mode. [1]

(a) "r": the file is opened for reading only; its existing contents are unchanged / can be read from the start (do not accept 'opens the file' alone)(1)
"w": the existing contents are erased / overwritten; writing starts with an empty file(1)
"a": the existing contents are kept and new data is added at the end of the file(1)
(b) An error / exception occurs (accept FileNotFoundError; reject 'a new file is created')(1)
(c) Any one: ensures buffered data is actually written (flushed) to the file / so the data is saved; releases the file (resource) so other programs or later code can use it; prevents the file being left locked or corrupted(1)
Answer: (a) r: read only, contents unchanged; w: contents wiped and overwritten; a: contents kept, new data added at the end. (b) Error (FileNotFoundError). (c) e.g. flushes buffered writes so the data is saved / frees the file for other use.
Examiner tip: Students often say "w" adds to the file: it destroys the existing contents the moment the file is opened, before anything is written.

3Core4 marks

The text file planets.txt contains four lines. Every line, including the last, ends with a newline character.

Mercury
Venus
Earth
Mars

The following Python code is run.

f = open("planets.txt", "r")
a = f.readline()
b = f.readline().strip()
rest = f.read()
f.close()
print(len(a), b)
print(rest.count("\n"))

(a) State the exact output of the program. [3]

(b) Distinguish between the methods readline() and read(). [1]

First line of output begins 8: a holds "Mercury\n", so the newline is counted (reject 7)(1)
First line of output continues with Venus (i.e. the line printed is 8 Venus)(1)
Second line of output is 2 (rest holds "Earth\nMars\n"; reject 4 or 3: read() continues from where the second readline() stopped)(1)
(b) readline() returns one line (up to and including the next newline) whereas read() returns all the remaining text in the file as a single string(1)
Answer: (a) 8 Venus then 2. (b) readline() reads the next single line; read() reads everything that is left.
Examiner tip: readline() keeps the trailing \n, so the length of "Mercury\n" is 8, not 7; and read() starts where the last readline() stopped, not at the top of the file.

Stuck on File processing?

Get it sorted in a free 30-minute session

We work through your weakest questions on this topic on Zoom. I reply the same day.

Free 30-min session on this topic Send me 5 questions a day

4Standard5 marks

A teacher wants to save a class register to a text file, one name per line. She writes this Python code.

names = ["Ava", "Ben", "Cal"]
for n in names:
    f = open("register.txt", "w")
    f.write(n + "\n")
    f.close()

(a) State the contents of register.txt after the code has run. [1]

(b) Explain why the file does not contain the whole register. [2]

(c) Construct a corrected version of the code so that all three names are saved, the file is opened only once and any previous contents of the file are replaced. [2]

(a) Only Cal (one line)(1)
(b) The file is opened in "w" mode inside the loop / once per name(1)
Each time it is opened in write mode the previous contents are erased, so each name overwrites the one before and only the last name survives(1)
(c) open("register.txt", "w") moved before the loop and close() moved after the loop (accept a with block surrounding the loop)(1)
write(n + "\n") remains inside the loop so every name is written on its own line (reject changing the mode to "a" inside the loop: file is then opened three times and old contents are not replaced)(1)

Answer: (a) Cal (b) "w" is opened inside the loop, so each opening erases the previous name. (c)

names = ["Ava", "Ben", "Cal"]
f = open("register.txt", "w")
for n in names:
    f.write(n + "\n")
f.close()

Examiner tip: Swapping "w" for "a" seems to fix it but keeps last lesson's names too: move the open and close outside the loop instead.

5Standard5 marks

The following Java code writes the square numbers 1, 4, 9 and 16 to a text file.

FileWriter fw = new FileWriter("squares.txt");
for (int i = 1; i <= 4; i++) {
    fw.write(String.valueOf(i * i));
}
fw.close();

(a) State the exact contents of squares.txt after the code has run. [1]

(b) Construct the change needed to line 3 so that each number is stored on its own line. [1]

(d) State how line 1 should be changed so that running the program again adds to the end of the file instead of replacing it. [1]

(a) 14916 on a single line (no separators)(1)
(b) fw.write(String.valueOf(i * i) + "\n"); (accept fw.write(i * i + "\n");, System.lineSeparator(), or a separate fw.write("\n") inside the loop)(1)
(c) FileWriter buffers the output / the data is held in memory and is only written (flushed) to the file when the file is closed (or flushed)(1)
So the file may be left empty or incomplete / the numbers may be lost (accept: the file stays open/locked so other programs cannot use it, as an alternative for one mark)(1)
(d) new FileWriter("squares.txt", true): the second argument true sets append mode(1)
Answer: (a) 14916 (b) fw.write(String.valueOf(i * i) + "\n"); (c) buffered data is not flushed, so the file can end up empty or incomplete. (d) new FileWriter("squares.txt", true)
Examiner tip: write() adds no newline of its own, so the numbers run together; you must write "\n" yourself.

6Standard5 marks

A shop stores its stock in the text file stock.txt. Each line holds an item name and the quantity in stock, separated by a comma.

pens,40
rulers,0
glue,12
erasers,0

The following Java code processes the file.

BufferedReader br = new BufferedReader(new FileReader("stock.txt"));
String line = br.readLine();
int out = 0;
while (line != null) {
    String[] parts = line.split(",");
    int qty = Integer.parseInt(parts[1]);
    if (qty == 0) {
        System.out.println(parts[0]);
        out++;
    }
    line = br.readLine();
}
br.close();
System.out.println(out + " out of stock");

(a) State the output of the code. [2]

(b) State the value returned by br.readLine() when the end of the file has been reached. [1]

(a) rulers and erasers printed, on separate lines, in that order(1)
Followed by 2 out of stock(1)
(b) null(1)
(c) line would never change / would always hold the first line pens,40, so line != null would stay true(1)
So the loop would never end (infinite loop) and no further lines would be processed (output nothing / the final message never printed)(1)
Answer: (a) rulers / erasers / 2 out of stock (b) null (c) the first line is processed forever: an infinite loop.
Examiner tip: The second readLine() at the bottom of the loop is what moves through the file; without it the condition never becomes false.

7Hard6 marks

A weather station records one temperature reading per line in the text file readings.txt, for example:

18.5
21.0
23.4
19.9
25.1

Construct a Python function copy_warm(threshold) that:

reads every reading from readings.txt;
writes each reading that is greater than or equal to threshold to a new file warm.txt, one reading per line, replacing any previous contents of warm.txt;
closes both files and returns the number of readings written.

For the example file, copy_warm(21.0) should return 3. You may assume the file exists and every line holds a valid number. [6]

Opens readings.txt in read mode "r" (accept default mode)(1)
Opens warm.txt in write mode "w" (reject "a", which keeps old contents)(1)
Loops through every line of the input file (for line in file / readline loop / readlines())(1)
Converts each line to a number with float() and compares it with threshold using >= (reject >; reject comparing strings)(1)
Writes qualifying readings with a newline after each (e.g. write(line.strip() + "\n"), or writes line unchanged if it already ends in \n; accept str(value))(1)
Counts readings written and returns the count, after closing both files (accept with blocks for closing)(1)

Answer:

def copy_warm(threshold):
    count = 0
    infile = open("readings.txt", "r")
    outfile = open("warm.txt", "w")
    for line in infile:
        value = float(line)
        if value >= threshold:
            outfile.write(line.strip() + "\n")
            count += 1
    infile.close()
    outfile.close()
    return count

Examiner tip: Values read from a file are strings: "9.5" >= "21.0" is True as text, so convert with float() before comparing.

8Hard5 marks

A program keeps a log in the text file log.txt. Before the program runs, the file contains one line, boot, followed by a newline. The program defines and uses this procedure.

def log(msg, mode):
    f = open("log.txt", mode)
    f.write(msg + "\n")
    f.close()

log("start", "a")
log("load", "a")
log("reset", "w")
log("run", "a")

f = open("log.txt", "r")
lines = f.readlines()
f.close()
print(len(lines))
print(lines[-1].strip())

(a) Deduce the contents of log.txt immediately before the call log("reset", "w"). [1]

(b) Deduce the contents of log.txt at the end of the program. [2]

(a) boot, start, load on three separate lines, in that order(1)
(b) The call in "w" mode erases the earlier lines, so boot, start and load are no longer in the file(1)
The file holds reset then run on two lines, in that order(1)
(c) 2 (follow through from their (b): number of lines stated)(1)
run (follow through from their (b): last line, without the newline)(1)
Answer: (a) boot / start / load (b) reset / run (c) 2 then run
Examiner tip: Opening in "w" mode wipes the file before anything is written, so the log is reduced to just the line written by that call.

9Stretch7 marks

A school library exports its overdue loans to the text file loans.txt. The first line is a header; each following line holds a student ID, a book title and the number of days overdue, separated by commas.

studentID,title,daysOverdue
S104,Dune,3
S221,Emma,0
S104,Ulysses,40
S318,Kim,12

The fine for a loan is 0.20 per day overdue, up to a maximum of 5.00 per loan. The file fines.txt already holds fines from earlier weeks, which must be kept.

Construct code in Python or Java that:

ignores the header line;
for every loan with at least one day overdue, adds a line studentID,fine to the end of fines.txt, with the fine to 2 decimal places (for example S104,0.60);
outputs the total of the new fines once all loans have been processed;
closes both files.

You may assume loans.txt exists and is correctly formatted. [7]

Opens loans.txt for reading (Python "r"; Java BufferedReader/FileReader or Scanner(new File(...)))(1)
Reads and discards the header line before processing (e.g. one readline()/nextLine() before the loop, or skips the first iteration)(1)
Opens fines.txt in append mode (Python "a"; Java new FileWriter("fines.txt", true)) (reject write mode, which loses earlier weeks)(1)
Loops through each remaining line and splits it on commas, converting the third field to an integer(1)
Calculates the fine as days × 0.20 and caps it at 5.00 (e.g. min(days * 0.20, 5.00) or an if statement)(1)
Writes studentID,fine with the fine formatted to 2 d.p. and a newline, only when days > 0(1)
Accumulates the fines and outputs the total after the loop, and closes both files(1)

Answer:

total = 0
infile = open("loans.txt", "r")
infile.readline()                # skip header
outfile = open("fines.txt", "a")
for line in infile:
    parts = line.strip().split(",")
    days = int(parts[2])
    if days > 0:
        fine = min(days * 0.20, 5.00)
        outfile.write(parts[0] + "," + format(fine, ".2f") + "\n")
        total += fine
infile.close()
outfile.close()
print("Total fines:", format(total, ".2f"))

For the sample file: lines S104,0.60, S104,5.00, S318,2.40 are appended and the total is 8.00.

Examiner tip: Using "w" instead of "a" silently deletes every earlier week's fines: read the brief for words like "kept" or "add to".

10Stretch6 marks

The text file notes.txt contains the four lines below; the second line is blank. Every line ends with a newline character.

alpha

beta
gamma

The following Python code is run.

f = open("notes.txt", "r")
count = 0
line = f.readline()
while line != "":
    count = count + 1
    line = f.readline()
f.close()
print(count)

(a) State the output. [1]

(b) Explain why the loop does not stop when it reaches the blank line. [2]

(d) Construct a change to the original code so that it counts only the lines that are not blank, while still reading the whole file. [2]

(a) 4(1)
(b) The blank line is read as "\n" / a string containing the newline character, which is not equal to the empty string ""(1)
readline() returns "" only at the end of the file, so the condition is false only at end of file(1)
(c) 1 (the loop now stops when it reaches the blank line, after counting alpha only)(1)
(d) Keeps the original while line != "": loop / still reads to end of file(1)
Increments count only if line.strip() != "" (accept line != "\n"; accept if line.strip():)(1)
Answer: (a) 4 (b) a blank line is "\n", not ""; readline() returns "" only at end of file. (c) 1 (d) if line.strip() != "": count = count + 1 inside the original loop (gives 3).
Examiner tip: An empty string from readline() means end of file; a blank line in the middle of a file still contains "\n".

Stuck on this topic?

Book a free 30-minute session on WhatsApp and we'll find exactly which step is costing you the marks. Or build a timed paper on it.

Free 30-minute session