Text Files

You cannot read a book that is still on the shelf — you have to take it down and open it first. A file works the same way. Before your program can touch a single character of a file, it must ask the operating system to open it, and it must say why it wants it (to read? to write?). Get this one line right and everything else in the chapter follows from it.

Python opens a file with the built-in open() function. It takes two things: the filename and the mode. It hands back a file handle — a variable you use for every later operation on that file.

file = open("data.txt", "r")   # filename, then mode
# ... read or write here ...
file.close()                       # always release the file

The mode is a one-letter string. There are exactly three you need for Paper 4, and the difference between them is the single most common source of lost marks in file questions:

• "r" — read. The file must already exist. If it does not, Python crashes with FileNotFoundError. Why? Because there is nothing to read.
• "w" — write. Creates the file if it does not exist. If it does exist, all existing content is wiped instantly, the moment the file opens — before you write anything.
• "a" — append. Creates the file if needed, but if it exists, the existing content is kept and new writes go on the end. Logs, registers and records grow — you add to them, you do not retype them.

And why does close() matter? Two reasons. First, written data is often held in a memory buffer and only physically saved to disk when the file closes — forget to close and your file can end up empty. Second, an open file is locked: other programs (or another part of your own program) may not be able to use it. Open, do the job, close. Every time.

Every useful system you have ever used saves something — your game saves progress, your school saves your marks, your phone saves messages. Writing to a file is how a program turns its temporary results into a permanent record. This is also the easiest mode to start with, because there is nothing to read: you create the file yourself.

Open the file in "w" mode and call write() on the handle. One detail trips everyone up: write() does not move to a new line by itself, the way print() does. If you want each item on its own line — and in Paper 4 you almost always do — you must add the newline character "\n" yourself.

file = open("greeting.txt", "w")   # creates the file (or wipes it)
file.write("Hello, world!\n")         # \n ends the line
file.write("Welcome to Paper 4.\n")
file.close()                            # data is now safely on disk

The file greeting.txt will contain:

Hello, world!
Welcome to Paper 4.

One more rule that costs marks: write() accepts strings only. If you try file.write(75) Python crashes with a TypeError, because a file is a sequence of characters and 75 is a number, not characters. Convert first: file.write(str(75) + "\\n").

This is the skill Paper 4 tests most. The exam gives you a ready-made data file — names, scores, stock records — and your very first job is to get that data out of the file and into your program. If you can read a file line by line confidently, you can start every file question on the paper.

There are two ways to read, and you should know when to use each:

1. Read everything at once with read(). This returns the whole file as one big string. It is fine for simply displaying a file, but useless when you need to process items one at a time.

file = open("register.txt", "r")
content = file.read()   # the entire file as ONE string
print(content)
file.close()

2. Loop line by line. This is the Paper 4 way. Python lets you put the file handle straight into a for loop — each pass of the loop gives you the next line, and the loop stops automatically at the end of the file (EOF). No counting, no checking — Python handles EOF for you.

file = open("register.txt", "r")
for line in file:                # one line per loop pass, stops at EOF
    print(line.strip())          # .strip() removes the invisible \n
file.close()

Output (assuming register.txt contains Musarrat, Tarnima, Aymaan):

Musarrat
Tarnima
Aymaan

Why .strip()? Remember that every line in the file ends with an invisible \n. When Python reads the line, that \n comes along with it. If you print without stripping, you get the line's own \n plus print's newline — double spacing. Worse, if you compare line == "Musarrat" it will be False, because the line is actually "Musarrat\n". Strip first, always.

Think about a school attendance log. Each day you add today's record — you do not retype the whole year. That is exactly what append mode is for: keep everything already in the file and add new lines to the end. If you used "w" instead, day 2 would erase day 1. Real systems — logs, registers, transaction histories — live and die by this distinction.

Open in "a" mode. Everything else — write(), str(), "\n", close() — works exactly as in section 8.2. The only change is where the new text lands: at the end of the existing content instead of replacing it.

file = open("register.txt", "a")   # existing names are KEPT
file.write("Mehrin\n")                # added after the last line
file.close()

If register.txt previously contained Musarrat, Tarnima, Aymaan, after running this it contains:

Musarrat
Tarnima
Aymaan
Mehrin

Forgetting close() is the most common file bug there is — and it can silently leave your file empty or locked. Python gives you a pattern that makes the mistake impossible: with opens the file and guarantees it closes when the indented block ends, even if the program crashes mid-way. Professional Python code uses it everywhere, and it is fully accepted in Paper 4.

with open("register.txt", "r") as file:   # opens, names the handle "file"
    for line in file:
        print(line.strip())
# the block has ended -- the file is ALREADY closed here

Read it as a sentence: "with this file open as file, do the following." Everything indented under the with line happens while the file is open. The instant the indentation ends, Python closes the file for you — no close() call, no way to forget it.

A file on disk is slow and can only be read forwards, line by line. A list in memory is fast and lets you jump to any element, sort, search and count. So every serious Paper 4 program follows the same plan: read the file into a list once, do all the work on the list, write results back at the end. This section is the bridge between Chapter 4 (lists) and everything the exam will throw at you.

Loading a file into a list is the read loop from 8.3 plus one extra line: instead of printing each cleaned line, append() it to a list you created empty before the loop.

numbers = []                              # 1. start with an empty list
file = open("numbers.txt", "r")            # 2. open to read
for line in file:                          # 3. one line per pass, stops at EOF
    numbers.append(int(line.strip()))      # 4. clean, convert, store
file.close()                               # 5. release the file
print(numbers)                             # [10, 20, 30, 40, 50]

If numbers.txt contains 10, 20, 30, 40, 50, the output is:

[10, 20, 30, 40, 50]

Look closely at line 4 — it does three jobs, inside-out: line.strip() removes the newline, int(…) converts the text "10" into the number 10, and numbers.append(…) stores it. Why convert? Because a file can only hold characters. The file contains the two characters "1" and "0", not the number ten. Until you convert, "10" + "20" gives "1020" — string joining, not addition.

Saving a list to a file is the mirror image: loop through the list and write each element with str() and "\n".

numbers = [10, 20, 30, 40, 50]
file = open("output.txt", "w")
for n in numbers:
    file.write(str(n) + "\n")
file.close()

Loading a file is never the whole question — it is the setup. The marks come from what you do next: count the values that meet a condition, split them into groups, find the largest, merge two sources. Each of these is a small pattern you already met in Chapters 3 and 4, now fed by file data instead of typed input. This section drills the four patterns the exam recycles again and again.

Pattern 1 — count with a condition

nums = []
file = open("numbers.txt", "r")
for line in file:
    nums.append(int(line.strip()))
file.close()

pos = 0
neg = 0
for n in nums:
    if n > 0:
        pos = pos + 1
    elif n < 0:
        neg = neg + 1

print("Positive:", pos)
print("Negative:", neg)

If numbers.txt contains -5, 12, -8, 0, 3, -1, the output is:

Positive: 2
Negative: 3

Notice that 0 is counted by neither branch — the elif chain deliberately lets it fall through. Always check what the question wants done with boundary values.

Pattern 2 — split into two lists

nums = []
file = open("numbers.txt", "r")
for line in file:
    nums.append(int(line.strip()))
file.close()

even = []
odd = []
for n in nums:
    if n % 2 == 0:
        even.append(n)
    else:
        odd.append(n)

print("Even:", even)
print("Odd:", odd)

Pattern 3 — file in, two files out

Combine pattern 2 with the saving loop from 8.6: after splitting, write each list to its own file.

nums = []
file = open("numbers.txt", "r")
for line in file:
    nums.append(int(line.strip()))
file.close()

evenFile = open("even.txt", "w")
oddFile = open("odd.txt", "w")
for n in nums:
    if n % 2 == 0:
        evenFile.write(str(n) + "\n")
    else:
        oddFile.write(str(n) + "\n")
evenFile.close()
oddFile.close()

Two files can be open at the same time — as long as each has its own handle and each gets its own close().

Pattern 4 — combine two files into one list

data1 = []
file1 = open("file1.txt", "r")
for line in file1:
    data1.append(int(line.strip()))
file1.close()

data2 = []
file2 = open("file2.txt", "r")
for line in file2:
    data2.append(int(line.strip()))
file2.close()

combined = data1 + data2   # + joins two lists end to end
print(combined)

Everything above was drilled one skill at a time. The real paper hands you one scenario and makes you chain the skills: read a file into a global array, process the array, write results out. Attempt this under timed conditions (about 18 minutes) before opening the mark scheme.

The program uses the global variables:

marks = []           # global 1D array of integers
numberMarks = 0     # global integer, the number of marks read

(a) ReadMarks(fileName) — [6 marks] AO3

Write the Python function ReadMarks(fileName) that takes the name of the file as a parameter, reads every mark from the file into the global array marks, stores the number of marks read in numberMarks, and returns numberMarks.

(b) CountDistinctions() — [3 marks] AO3

Write the Python function CountDistinctions() that returns the number of marks in the array that are greater than or equal to 75.

(c) SaveSummary() — [4 marks] AO3

Write the Python procedure SaveSummary() that writes two lines to a new text file summary.txt:

• the first line contains the number of marks, in the form Total: 25
• the second line contains the number of distinctions, in the form Distinctions: 7

Your procedure should call CountDistinctions().

(d) Why is "w" wrong? — [1 mark] AO1

State one reason why opening results.txt in "w" mode in part (a) would be incorrect.

Total: 14 marks

Fifteen exam-style file-handling tasks. Each has a Hint (thought process, bullet points) and a Help button (full Python solution). Try the task first, use the Hint if you are stuck, then check the Help to verify.