Files and data formats

Make a day14 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days. Several programs today read a small data file, such as poem.txt or class_scores.csv. Each one is shown on the page; type it into a file with that exact name in the same folder as the script, or download it with the example.

Every program you have written so far forgets everything when it stops. The Day 12 to-do manager is a good example: add five tasks, choose Quit, run it again, and the list is empty. Variables live in the computer’s memory, which is wiped when the program ends. To keep anything, a program has to write it somewhere that lasts: a file. Today you learn to read files, write them, find them with paths, and store data in two formats that other programs understand, CSV and JSON. By the end, the to-do manager will remember its tasks.

You already use files every day: documents, photos, and the .py scripts you have written since Day 1. A file is a named block of data saved on a disk, where it stays after programs stop and even after the computer is switched off. The part of the name after the last dot, such as .txt or .py, is the extension; it hints at what kind of data is inside. Today’s programs work with text files: files that hold characters you could open and read in any editor, such as .txt, .csv, and .json files, and your own .py scripts.

Here is the text file used in the next few sections. Save it as poem.txt in your day14 folder:

Roses are red,
violets are blue,
Python reads files,
and so can you.

Reading a file takes three steps, like reading a book: open it, read it, close it.

1. The built-in function open() takes a file name and returns a file object: a value that is connected to the file and has methods for reading from it or writing to it. Opening does not read anything yet.
2. The file object’s read() method reads the whole file and returns it as one string.
3. The close() method disconnects the file object from the file. You will see why that matters in 14.2.

file = open("poem.txt", encoding="utf-8")
text = file.read()
file.close()
print(text)
print("Characters:", len(text))

Roses are red,
violets are blue,
Python reads files,
and so can you.

Characters: 69

How does open("poem.txt") know where poem.txt is? A name with no folder in front of it is looked up in the program’s current working directory: the folder the terminal is in when you type python read_poem.py. Since you open the terminal in your day14 folder, that is where Python looks. (14.6 shows how to find a file next to the script wherever you run it from.)

If no file has that name in that folder, open() stops the program. Here the name has a typo, .text instead of .txt:

file = open("poem.text", encoding="utf-8")
text = file.read()
file.close()
print(text)

Traceback (most recent call last):
  File ".../day14/missing_file.py", line 1, in <module>
    file = open("poem.text", encoding="utf-8")
FileNotFoundError: [Errno 2] No such file or directory: 'poem.text'

Read the last line first, as on Day 1: a FileNotFoundError names the file Python could not find. ([Errno 2] is the operating system’s code number for “no such file”.) Check three things: the spelling, including the extension; that the file is in the folder you ran the program from; and the capitals, because on Linux Poem.txt and poem.txt are two different files. Day 15 shows how a program can catch this error and carry on.

file = open("poem.txt", encoding="utf-8")
text = file.read()
file.close()
print(text[:5])
print(text.count("\n"))

Roses
4

read_poem.py called close() by hand. That works until something goes wrong between open and close. If line 2 stopped the program with an error, line 3 would never run, and the file would stay open. Leaving files open causes real problems: the operating system limits how many files one program may have open at once; on Windows, an open file often cannot be renamed or deleted; and when you write a file, the text may not reach the disk until the file is closed (14.4 shows this happening). You need a way to say “close this file when I am done with it, whatever happens”.

The with statement opens a file, runs an indented block, and closes the file automatically when the block ends, even if the block ends with an error:

with open("poem.txt", encoding="utf-8") as file:
    statement
    statement

• with is a keyword, followed by the expression that opens the file.
• as file names the file object, exactly as file = open(...) did.
• The colon and the indented block follow the same rules as if and for. The block is where you use the file.
• When Python leaves the block, by reaching its end or because of an error, it closes the file for you. There is no close() to forget.

A file object has an attribute called closed: a value that belongs to the object, written after a dot like a method but with no parentheses. It is True once the file is closed. Watch it change:

with open("poem.txt", encoding="utf-8") as file:
    text = file.read()
    print("Inside:", file.closed)

print("After:", file.closed)
print(text.upper())

Inside: False
After: True
ROSES ARE RED,
VIOLETS ARE BLUE,
PYTHON READS FILES,
AND SO CAN YOU.

From now on, every program in this course opens files with with. It is shorter than open plus close, and the file is closed even when something goes wrong.

with open("poem.txt", encoding="utf-8") as file:
    first = file.read()

again = file.read()
print(again)

Traceback (most recent call last):
  File ".../day14/closed_read.py", line 4, in <module>
    again = file.read()
ValueError: I/O operation on closed file.

read() gives you the whole file as one big string. Many files are made of lines that each mean something on their own: one task, one score, one log entry. You want to handle them one at a time, and for a large file you do not want to hold the whole thing in memory at once.

A file object works like a sequence of lines: a for loop over a file runs its body once per line, with the loop variable holding that line as a string. Python reads the file a piece at a time as the loop goes, so even a huge file uses little memory. The REPL shows what each line really contains, because it displays strings with their escape characters (Day 3):

>>> file = open("poem.txt", encoding="utf-8")
>>> file.readline()
'Roses are red,\n'
>>> file.readline()
'violets are blue,\n'
>>> file.close()

>>> with open("poem.txt", encoding="utf-8") as file:
...     lines = file.readlines()
...
>>> lines
['Roses are red,\n', 'violets are blue,\n', 'Python reads files,\n', 'and so can you.\n']
>>> len(lines)
4

• readline() reads one line each time you call it. The REPL shows 'Roses are red,\n': each line keeps the "\n" that ended it in the file.
• readlines() reads every line into a list (Day 6), one string per line, each still ending in "\n".

That "\n" is the thing to watch. Here is the most natural loop:

with open("poem.txt", encoding="utf-8") as file:
    for line in file:
        print(line)

Roses are red,

violets are blue,

Python reads files,

and so can you.

The poem comes out double-spaced. Each line already ends with "\n", and print adds a second one. Remove the line’s own new line with strip() (Day 3) before using it. Together with enumerate() from Day 5, this numbers the lines:

with open("poem.txt", encoding="utf-8") as file:
    for number, line in enumerate(file, 1):
        print(f"{number}: {line.strip()}")

1: Roses are red,
2: violets are blue,
3: Python reads files,
4: and so can you.

Three ways to read, side by side:

The last row uses the string method splitlines(), which splits a string at its line breaks and drops them. It is like split("\n"), but it does not leave an empty string at the end when the text ends with a new line.

with open("poem.txt", encoding="utf-8") as file:
    for number, line in enumerate(file, 1):
        if len(line.strip()) > 15:
            print(number, line.strip())

2 violets are blue,
3 Python reads files,

Reading lets a program use data someone else saved. To keep its own data, a program must write. open() takes a second argument, the mode: a short string that says what you plan to do with the file. Without it, the mode is "r", read. For writing, the mode is "w":

with open("shopping.txt", "w", encoding="utf-8") as file:
    file.write("eggs\n")

Mode "w" does two things at once. If the file does not exist, it creates it. If it does exist, it empties it first, throwing away everything that was in it. Then the file object’s write() method adds the string you give it to the file.

with open("shopping.txt", "w", encoding="utf-8") as file:
    file.write("eggs\n")
    file.write("bread\n")
    file.write("milk\n")

with open("shopping.txt", encoding="utf-8") as file:
    print(file.read())

eggs
bread
milk

write() does not work like print(). It writes exactly the characters you give it, nothing more. In particular, it does not add a new line:

with open("shopping.txt", "w", encoding="utf-8") as file:
    file.write("eggs")
    file.write("bread")
    file.write("milk")

with open("shopping.txt", encoding="utf-8") as file:
    print(file.read())

eggsbreadmilk

The three words run together into one line, because no "\n" was ever written. Each write() continues right where the last one stopped.

write() also accepts only strings. To save numbers, turn them into text first, and an f-string (Day 3) is the neatest way. A loop over a dictionary’s items (Day 8) writes one line per entry:

prices = {"apples": 3.5, "rice": 2.25, "tea": 4}

with open("prices.txt", "w", encoding="utf-8") as file:
    for item, price in prices.items():
        file.write(f"{item}: ${price:.2f}\n")

with open("prices.txt", encoding="utf-8") as file:
    print(file.read())

apples: $3.50
rice: $2.25
tea: $4.00

Each pass builds one line with the price shown to two decimal places and a "\n" at the end.

If you try write() in the REPL, it also shows a number after each call: write() returns how many characters it wrote, and a script simply ignores it.

file = open("draft.txt", "w", encoding="utf-8")
file.write("Dear Sam,\n")

reader = open("draft.txt", encoding="utf-8")
print("Read back:", len(reader.read()), "characters")
reader.close()

file.close()

reader = open("draft.txt", encoding="utf-8")
print("After close:", len(reader.read()), "characters")
reader.close()

Read back: 0 characters
After close: 10 characters

scores = [72, 88, 95]

with open("scores_out.txt", "w", encoding="utf-8") as file:
    for score in scores:
        file.write(score)

TypeError: write() argument must be str, not int

scores = [72, 88, 95]

with open("scores_out.txt", "w", encoding="utf-8") as file:
    for score in scores:
        file.write(f"{score}\n")

with open("scores_out.txt", encoding="utf-8") as file:
    print(file.read())

72
88
95

A training log gets one new line every day. Mode "w" is wrong for that job: each run would empty the file and keep only today’s entry. You need to add to the end and keep what is already there.

Mode "a", append, opens a file for writing at its end. Nothing is erased; each write() adds after the last character already in the file. If the file does not exist yet, "a" creates it, just as "w" does.

with open("log.txt", "w", encoding="utf-8") as file:
    file.write("Training log\n")

with open("log.txt", "a", encoding="utf-8") as file:
    file.write("Monday: ran 3 km\n")

with open("log.txt", "a", encoding="utf-8") as file:
    file.write("Tuesday: swam 20 laps\n")

with open("log.txt", encoding="utf-8") as file:
    print(file.read())

Training log
Monday: ran 3 km
Tuesday: swam 20 laps

Change the two appends to "w" and watch the difference:

with open("log.txt", "w", encoding="utf-8") as file:
    file.write("Training log\n")
    file.write("Monday: ran 3 km\n")

with open("log.txt", "w", encoding="utf-8") as file:
    file.write("Tuesday: swam 20 laps\n")

with open("log.txt", encoding="utf-8") as file:
    print(file.read())

Tuesday: swam 20 laps

The second open with "w" emptied the file, so the title and Monday’s entry are gone. Nothing warns you: Python assumes you meant it.

"r" is the default, which is why the reading examples could leave the mode out. A file opened with "r" can only be read, and one opened with "w" or "a" can only be written; you will see the error in the review questions.

with open("visits.txt", "a", encoding="utf-8") as file:
    file.write("visit\n")

So far every file name has been a plain name in the current folder. Real programs keep files in folders: reports/march/sales.csv. You could glue names together with strings, "reports" + "/" + "march", but Windows writes folder separators as \ while macOS and Linux use /, and string-gluing makes it easy to get doubled or missing separators.

A path is the location of a file or folder written as a chain of folder names ending in a name, such as reports/march/sales.csv. The standard library module pathlib (Day 13 showed how to import from the standard library) has a type, Path, for working with paths as values instead of strings. Build a path by joining parts with the / operator; Python uses the right separator for your computer.

from pathlib import Path

report = Path("reports") / "march" / "sales.csv"
print(report)
print(report.name)
print(report.stem)
print(report.suffix)
print(report.parent)

reports/march/sales.csv
sales.csv
sales
.csv
reports/march

A Path also has methods that do use the disk. exists() asks whether a file or folder is really there. read_text() and write_text() open, read or write, and close a file in one call, which is handy for small files. And path.open() works just like open(path), with the same modes; open() itself also accepts a Path.

from pathlib import Path

poem = Path("poem.txt")
print(poem.exists())
print(Path("poems.txt").exists())

text = poem.read_text(encoding="utf-8")
print(text.splitlines()[0])

copy = Path("poem_copy.txt")
copy.write_text(text.upper(), encoding="utf-8")
print(copy.read_text(encoding="utf-8"))

True
False
Roses are red,
ROSES ARE RED,
VIOLETS ARE BLUE,
PYTHON READS FILES,
AND SO CAN YOU.

poem.txt is in the folder, so line 4 prints True; there is no poems.txt, so line 5 prints False (no error: exists() only asks). Line 7 reads the whole poem, and line 8 prints its first line using splitlines() from 14.3. Line 11 writes a capitalized copy to a new file, poem_copy.txt, replacing it if it exists, like mode "w". exists() lets a program check for a file before opening it, which the to-do manager will use in 14.10.

Relative and absolute paths. Path("poem.txt") is a relative path: it is looked up starting from the current working directory, the folder you ran python from. An absolute path starts at the top of the disk (on macOS, something like /Users/ana/day14/poem.txt; on Windows, C:\Users\ana\day14\poem.txt) and means the same file wherever you run from. Writing your own absolute paths into a program is a bad idea, because the program then works only on your computer.

Relative paths cause a classic surprise. If your terminal is in the folder above day14 and you run python day14/read_poem.py, Python finds the script, but open("poem.txt") looks in the folder you are in, not in day14, and you get FileNotFoundError. Some editors’ Run buttons do the same. The fix is to build the path from the script’s own location. When Python runs a script, it stores the script’s path in a special variable, __file__ (two underscores on each side, like __name__ from Day 13). Path(__file__).parent is therefore the folder the script is in:

from pathlib import Path

here = Path(__file__).parent
poem = here / "poem.txt"

with poem.open(encoding="utf-8") as file:
    lines = file.readlines()

print(poem.name, "has", len(lines), "lines")

poem.txt has 4 lines

Line 3 gets the script’s folder, and line 4 joins poem.txt onto it. Now the program finds the poem whether you run it as python here.py from day14 or as python day14/here.py from the folder above.

from pathlib import Path

photo = Path("photos") / "2026" / "beach.jpeg"
print(photo.name)
print(photo.stem)
print(photo.suffix)
print(photo.parent.name)

beach.jpeg
beach
.jpeg
2026

Every example so far has passed encoding="utf-8". Here is why, and what happens without it.

A disk does not store characters. It stores bytes: small numbers from 0 to 255. To save text, each character must be turned into bytes, and to read text, the bytes must be turned back into characters. A text encoding is the rule for doing that. UTF-8 is the encoding almost all files and web pages use today: it can store every character in every language, plus emoji, and plain English letters take one byte each, while other characters take two to four.

A string’s encode() method shows the bytes an encoding would produce. Python displays bytes as b'...', with each byte that is not a plain English character written as \x and two hexadecimal (base-16) digits:

>>> len("cafe")
4
>>> len("café")
4
>>> "cafe".encode("utf-8")
b'cafe'
>>> "café".encode("utf-8")
b'caf\xc3\xa9'
>>> len("café".encode("utf-8"))
5

"café" is 4 characters but 5 bytes in UTF-8: c, a, and f take one byte each, and é takes two, \xc3\xa9. That is the important point: the same bytes mean different characters under different encodings. If a file is written with one encoding and read with another, the text comes back wrong.

from pathlib import Path

menu = Path("menu.txt")
menu.write_text("Café: crème brûlée\n", encoding="utf-8")

print(menu.read_text(encoding="utf-8"))
print(menu.read_text(encoding="cp1252"))

Café: crème brûlée

Café: crème brûlée

Sometimes the bytes do not make sense in the encoding at all, and Python stops. Here a file is written in cp1252, where é is the single byte \xe9, and read as UTF-8:

from pathlib import Path

menu = Path("menu_old.txt")
menu.write_text("Café\n", encoding="cp1252")

print(menu.read_text(encoding="utf-8"))

Traceback (most recent call last):
  ...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe9 in position 3: invalid continuation byte

A codec is Python’s word for an encoding. The message says that byte number 3 (counting from 0: C, a, f, then é) is not valid UTF-8. Older Python versions may word the end of the message a little differently.

So why does the encoding have to be written out? When you leave encoding out, open() uses your computer’s default encoding. On macOS and Linux that is usually UTF-8, but on many Windows computers it is not. A program without encoding="utf-8" can work perfectly on one computer and show mojibake, or crash, on a friend’s. Writing the encoding makes the program behave the same everywhere.

A teacher’s gradebook, a bank statement, a list of cities and their temperatures: data shaped like a table, with rows and columns, is everywhere. Spreadsheet programs can save a table as a CSV file, and almost every data tool can read one.

CSV stands for comma-separated values. A CSV file is a text file in which each line is one row of a table and commas separate the values in the row. The first row is usually a header: the names of the columns. Save this as class_scores.csv:

name,score
Ana,88
Ben,92
"Lopez, Maya",79
Sam,95

Look at the fourth line. A value that contains a comma is wrapped in double quotes, so the comma inside it is not a separator. That is the CSV rule, and it is why splitting each line at commas is not enough:

with open("class_scores.csv", encoding="utf-8") as file:
    for line in file:
        print(line.strip().split(","))

['name', 'score']
['Ana', '88']
['Ben', '92']
['"Lopez', ' Maya"', '79']
['Sam', '95']

split(",") breaks "Lopez, Maya" into two pieces, with the quote marks still attached, and the row now has three values instead of two. Quotes inside quoted values, and line breaks inside values, make the rules more complicated still. The standard library module csv knows all of them.

csv.reader(file) goes through an open file and gives each row as a list of strings, one per column, with quotes handled. When you open a file for the csv module, pass newline="": it tells open() to hand the line endings to the csv module untouched, so the module can deal with them itself. The csv documentation asks for this whenever you open a CSV file.

import csv

with open("class_scores.csv", encoding="utf-8", newline="") as file:
    rows = list(csv.reader(file))

print(rows[0])
for row in rows[1:]:
    name = row[0]
    score = int(row[1])
    print(f"{name:12} {score:3}")

['name', 'score']
Ana           88
Ben           92
Lopez, Maya   79
Sam           95

Using row[1] means remembering which column is which. csv.DictReader(file) reads the header for you and gives each later row as a dictionary (Day 8) whose keys are the column names:

import csv

total = 0
count = 0
with open("class_scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        print(row)
        total += int(row["score"])
        count += 1

print(f"Average: {total / count:.1f}")

{'name': 'Ana', 'score': '88'}
{'name': 'Ben', 'score': '92'}
{'name': 'Lopez, Maya', 'score': '79'}
{'name': 'Sam', 'score': '95'}
Average: 88.5

The header row is not given to the loop; it supplied the keys. row["score"] says what it means, and the program keeps working if someone adds a column in the middle of the file. The values are still strings, so line 8 converts each score before adding it. The four scores total 354, and 354 / 4 is 88.5.

Writing works the other way round. csv.writer(file) makes a writer object whose writerow(values) method writes one list as one row, adding commas, quotes where needed, and the line ending:

import csv

honor_roll = [("Ben", 92), ("Lopez, Maya", 91), ("Sam", 95)]

with open("honor_roll.csv", "w", encoding="utf-8", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["name", "score"])
    for name, score in honor_roll:
        writer.writerow([name, score])

with open("honor_roll.csv", encoding="utf-8") as file:
    print(file.read())

name,score
Ben,92
"Lopez, Maya",91
Sam,95

• Line 3 holds the rows as a list of tuples (Day 7), and line 8 unpacks each tuple into name and score.
• writerow accepts numbers and turns them into text itself; unlike write(), it is not limited to strings.
• "Lopez, Maya" comes out with quotes, because it contains a comma. The other names need none.
• Line 5 opens the file with newline="". The csv module ends each row with its own line ending; without newline="", Windows would add a second one, and the file would show a blank line between rows.

import csv

total = 0
with open("class_scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        total += row["score"]

print("Total:", total)

Traceback (most recent call last):
  File ".../day14/csv_sum_bug.py", line 6, in <module>
    total += row["score"]
TypeError: unsupported operand type(s) for +=: 'int' and 'str'

import csv

total = 0
with open("class_scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        total += int(row["score"])

print("Total:", total)

Total: 354

import csv

names = []
with open("class_scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        if int(row["score"]) >= 90:
            names.append(row["name"])

print(len(names), names)

2 ['Ben', 'Sam']

CSV is perfect for one flat table, but much of a program’s data is not flat. The to-do manager has a list of dictionaries; a game might save a dictionary holding a list of players, each with a list of items. Squeezing that into rows and columns is awkward, and every value would come back as a string.

JSON (JavaScript Object Notation, usually said “jay-son”) is a text format for nested data. It looks almost exactly like Python’s lists and dictionaries, which makes it easy to read:

The standard library module json turns Python values into JSON text and back. Turning a value into text that can be stored or sent is called serializing it. Two functions work with strings, which makes them easy to try in the REPL: json.dumps(value) returns the JSON text for a value, and json.loads(text) turns JSON text back into Python values (the s stands for string).

>>> import json
>>> book = {"title": "Holes", "pages": 233, "read": True, "rating": None}
>>> text = json.dumps(book)
>>> text
'{"title": "Holes", "pages": 233, "read": true, "rating": null}'
>>> type(text)
<class 'str'>
>>> back = json.loads(text)
>>> back
{'title': 'Holes', 'pages': 233, 'read': True, 'rating': None}
>>> back == book
True

text is a plain string. Inside it, True became true and None became null, as the table says. json.loads reads it back into a dictionary equal to the original.

Not everything survives the trip unchanged, and some values cannot make it at all:

>>> import json
>>> data = {"point": (3, 4), 7: "lucky"}
>>> json.loads(json.dumps(data))
{'point': [3, 4], '7': 'lucky'}
>>> json.dumps({"red", "blue"})
Traceback (most recent call last):
  ...
TypeError: Object of type set is not JSON serializable

• The tuple (3, 4) comes back as the list [3, 4]: JSON has only one kind of sequence.
• The int key 7 comes back as the string '7': JSON object keys are always strings.
• A set cannot be saved at all. JSON has nothing like a set, so dumps stops with a TypeError. Convert it to a list first, list(tags).

For files there are two matching functions without the s. json.dump(value, file) writes the JSON for value into an open file, and json.load(file) reads a whole JSON file and returns the Python value. Here are two separate programs. The first saves a reading log:

import json

reading_log = [
    {"title": "Holes", "pages": 233, "finished": True},
    {"title": "Wonder", "pages": 310, "finished": False},
]

with open("reading_log.json", "w", encoding="utf-8") as file:
    json.dump(reading_log, file, indent=2)

print("Saved", len(reading_log), "books")

Saved 2 books

[
  {
    "title": "Holes",
    "pages": 233,
    "finished": true
  },
  {
    "title": "Wonder",
    "pages": 310,
    "finished": false
  }
]

import json

with open("reading_log.json", encoding="utf-8") as file:
    reading_log = json.load(file)

for book in reading_log:
    mark = "x" if book["finished"] else " "
    print(f"[{mark}] {book['title']} ({book['pages']} pages)")

[x] Holes (233 pages)
[ ] Wonder (310 pages)

import json

settings = {"theme": "dark", "volume": 7}

with open("settings.json", "w", encoding="utf-8") as file:
    json.dump(file, settings)

Traceback (most recent call last):
  ...
TypeError: Object of type TextIOWrapper is not JSON serializable

{
  "name": "Riverside Otters",
  "players": [
    { "name": "Ana", "goals": 4 },
    { "name": "Ben", "goals": 7 },
    { "name": "Kai", "goals": 2 }
  ]
}

import json

with open("team.json", encoding="utf-8") as file:
    team = json.load(file)

print(team["name"])
print(len(team["players"]))
print(team["players"][1]["goals"])
total = sum(player["goals"] for player in team["players"])
print(total)

Riverside Otters
3
7
13

You now have every piece needed to make a program remember. The question is when to read and write. A program that keeps its data in a file follows a simple pattern:

1. Load when the program starts. If the save file exists, read the data from it. If it does not (the very first run), start with an empty or default value.
2. Work with the data in memory, in ordinary lists and dictionaries, exactly as before.
3. Save after every change. Write the whole data structure back to the file with mode "w", replacing the old copy.

Putting load and save into two small functions keeps the rest of the program free of file details. The program below plays three runs one after another, so you can watch each run pick up where the last one stopped:

import json
from pathlib import Path


def save_books(books, path):
    with path.open("w", encoding="utf-8") as file:
        json.dump(books, file, indent=2)


def load_books(path):
    with path.open(encoding="utf-8") as file:
        return json.load(file)


path = Path("books.json")

# First run: start with one book and save it.
save_books([{"title": "Holes", "pages": 233}], path)

# Next run: a fresh program loads what was saved, adds a book, saves again.
books = load_books(path)
books.append({"title": "Wonder", "pages": 310})
save_books(books, path)

# The run after that sees both books.
for book in load_books(path):
    print(book["title"], book["pages"])

Holes 233
Wonder 310

Why save after every change instead of once, when the user quits? Because programs do not always get to quit politely. A crash, Ctrl+C (Day 5), a closed terminal window, or a power cut ends the program at once, and anything changed since the last save is lost. Saving after each change means the file is never more than one change behind. The lists in today’s programs are small, so writing the whole list each time is fast.

On the first run there is no file yet, and load_books would stop with FileNotFoundError. Use exists() from 14.6 to choose:

if path.exists():
    books = load_books(path)
else:
    books = []

(Day 15 shows another way to handle a missing file, and how to cope with a save file that has been damaged.)

A teacher keeps three quiz scores per student in quiz_scores.csv, saved from a spreadsheet:

name,quiz1,quiz2,quiz3
Ana,8,9,10
Ben,7,6,9
"Lopez, Maya",10,9,9
Sam,5,8,7

This program works out each student’s average, saves the results as JSON for another program to use, and then reads the JSON back to print a report:

import csv
import json
from pathlib import Path

here = Path(__file__).parent
scores_path = here / "quiz_scores.csv"
report_path = here / "grade_report.json"

averages = {}
with scores_path.open(encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        quizzes = [int(row["quiz1"]), int(row["quiz2"]), int(row["quiz3"])]
        averages[row["name"]] = round(sum(quizzes) / len(quizzes), 1)

with report_path.open("w", encoding="utf-8") as file:
    json.dump(averages, file, indent=2)

with report_path.open(encoding="utf-8") as file:
    report = json.load(file)

for name, average in report.items():
    print(f"{name:12} {average:4}")
print("Saved", report_path.name)

Ana           9.0
Ben           7.3
Lopez, Maya   9.3
Sam           6.7
Saved grade_report.json

The CSV file’s quotes around Lopez, Maya never show up anywhere: the csv module removed them while reading, and the JSON file stores the name as an ordinary string. After running, open grade_report.json in your editor to see the saved averages.

• open() connects to a file; inside a with block, read() gives the whole text and for line in file: gives one line at a time, each ending in "\n" (strip it). The block closes the file, even after an error.
• The mode decides what happens to an existing file: "r" reads it, "w" empties and replaces it, "a" adds to the end. write() takes only strings and adds no new lines.
• pathlib.Path builds paths with / that work on every system, takes them apart with .name, .stem, .suffix, and .parent, and checks the disk with exists(). Path(__file__).parent finds files next to the script.
• Files hold bytes, and an encoding turns them into characters. Always pass encoding="utf-8".
• Use the csv module (opened with newline="") for tables, where every value is read as a string, and the json module for nested lists and dictionaries, which come back with their types.
• To keep data between runs, load when the program starts and save after every change.

Do these in your day14 folder. Type each program yourself, run it, and only then open the answer.

The quick brown fox
jumps over the lazy dog.

Then it naps.

from pathlib import Path

path = Path("sample.txt")
text = path.read_text(encoding="utf-8")

lines = text.splitlines()
words = text.split()

print("Lines:", len(lines))
print("Words:", len(words))
print("Characters:", len(text))

Lines: 4
Words: 12
Characters: 60

name,score
Ana,88
Ben,92
Kai,79
Sam,95
Zoe,81

import csv

scores = []
with open("scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.DictReader(file):
        scores.append(int(row["score"]))

average = sum(scores) / len(scores)
print(f"{len(scores)} students, average score {average:.1f}")

5 students, average score 87.0

"""Task functions for the to-do manager. main.py imports them."""

import json


def show_menu():
    """Print the menu of choices."""
    print()
    print("1) Add  2) List  3) Complete  4) Delete  5) Quit")


def add_task(tasks, title):
    """Add a new, unfinished task to the end of tasks."""
    tasks.append({"title": title, "done": False})


def list_tasks(tasks):
    """Print every task with its number and a check box."""
    if not tasks:
        print("No tasks yet.")
        return
    for number, task in enumerate(tasks, 1):
        mark = "x" if task["done"] else " "
        title = task["title"]
        print(f"{number}. [{mark}] {title}")


def complete_task(tasks, number):
    """Mark task number (counting from 1) as done.

    Return the task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    task = tasks[number - 1]
    task["done"] = True
    return task


def delete_task(tasks, number):
    """Remove task number (counting from 1) from tasks.

    Return the removed task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    return tasks.pop(number - 1)


def save_tasks(tasks, path):
    """Write tasks to the JSON file at path, replacing what was there."""
    with path.open("w", encoding="utf-8") as file:
        json.dump(tasks, file, indent=2)


def load_tasks(path):
    """Read the JSON file at path and return its list of tasks."""
    with path.open(encoding="utf-8") as file:
        return json.load(file)


if __name__ == "__main__":
    test_tasks = []
    add_task(test_tasks, "Test the module")
    print(complete_task(test_tasks, 1))
    print(complete_task(test_tasks, 2))
    list_tasks(test_tasks)

"""The to-do manager's menu loop. Run this file to start the program."""

from pathlib import Path

from tasks import (
    add_task,
    complete_task,
    delete_task,
    list_tasks,
    load_tasks,
    save_tasks,
    show_menu,
)

SAVE_FILE = Path(__file__).parent / "tasks.json"


def main():
    """Run the menu loop until the user chooses Quit."""
    if SAVE_FILE.exists():
        tasks = load_tasks(SAVE_FILE)
    else:
        tasks = []
    print("To-do list manager")
    print(f"Loaded {len(tasks)} tasks from {SAVE_FILE.name}")
    while True:
        show_menu()
        choice = input("Choose 1-5: ").strip()
        if choice == "1":
            title = input("Task title: ").strip()
            if title:
                add_task(tasks, title)
                save_tasks(tasks, SAVE_FILE)
                print(f"Added: {title}")
            else:
                print("A task needs a title.")
        elif choice == "2":
            list_tasks(tasks)
        elif choice in ("3", "4"):
            text = input("Task number: ").strip()
            if not text or not all(ch in "0123456789" for ch in text):
                print("Please type a task number, such as 1.")
                continue
            number = int(text)
            if choice == "3":
                task = complete_task(tasks, number)
                action = "Completed"
            else:
                task = delete_task(tasks, number)
                action = "Deleted"
            if task is None:
                print(f"There is no task {number}.")
            else:
                save_tasks(tasks, SAVE_FILE)
                title = task["title"]
                print(f"{action}: {title}")
        elif choice == "5":
            print("Goodbye!")
            break
        else:
            print("Please choose a number from 1 to 5.")


if __name__ == "__main__":
    main()

To-do list manager
Loaded 2 tasks from tasks.json

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 2
1. [x] Return library books
2. [ ] Practice piano

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 1
Task title: Water the plants
Added: Water the plants

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 3
Task number: 2
Completed: Practice piano

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 4
Task number: 7
There is no task 7.

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 2
1. [x] Return library books
2. [x] Practice piano
3. [ ] Water the plants

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 5
Goodbye!

with open("chores.txt", "w", encoding="utf-8") as file:
    file.write("dishes\n")
    file.write("laundry\n")
    file.write("trash\n")

with open("chores.txt", "a", encoding="utf-8") as file:
    file.write("plants\n")

count = 0
with open("chores.txt", encoding="utf-8") as file:
    for line in file:
        if "s" in line:
            count += 1

print(count)

3

with open("tally.txt", "w", encoding="utf-8") as file:
    file.write("12\n")
    file.write("30\n")

with open("tally.txt", "w", encoding="utf-8") as file:
    for line in file:
        print(int(line) * 2)

io.UnsupportedOperation: not readable

with open("tally.txt", "w", encoding="utf-8") as file:
    file.write("12\n")
    file.write("30\n")

with open("tally.txt", encoding="utf-8") as file:
    for line in file:
        print(int(line) * 2)

24
60

import csv

with open("class_scores.csv", encoding="utf-8", newline="") as file:
    for row in csv.reader(file):
        print(len(row), row[0])

2 name
2 Ana
2 Ben
2 Lopez, Maya
2 Sam

from pathlib import Path

here = Path(__file__).parent
scores_path = here / "quiz_scores.csv"

The official Python Tutorial covers today’s files in Input and Output: Reading and Writing Files, including a short section on saving structured data with json. The library reference pages for pathlib and csv list every method used today and many more.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can open a text file and read all of it into a string. Reread
• I can explain why with is better than calling close() myself. Reread
• I can loop over the lines of a file and strip their new lines. Reread
• I can write lines to a file and remember to add "\n" myself. Reread
• I can choose between the modes "r", "w", and "a" for a job. Reread
• I can build a path with Path and / and find a file next to my script. Reread
• I can explain what an encoding is and why I pass encoding="utf-8". Reread
• I can read and write CSV files with the csv module. Reread
• I can save lists and dictionaries as JSON and load them back. Reread
• I can make a program load its data when it starts and save after each change. Reread