Quiz: File Input and Output

Test your understanding before moving on. Target: 70% or higher to proceed confidently.

Section 1: Multiple Choice (1 point each)

1. What does the "r" mode do when passed to open()?

• A) Creates a new file for reading
• B) Opens an existing file for reading (error if file doesn't exist)
• C) Opens a file for reading, creating it if it doesn't exist
• D) Opens a file for both reading and writing

2. What happens to an existing file's content when you open it in "w" mode?

• A) The content is preserved, and new data is added at the end
• B) The content is preserved, and new data is added at the beginning
• C) The content is immediately erased, even before you write anything
• D) The content is backed up and then erased

3. Which of the following is the PRIMARY benefit of using with open(...) as f: instead of f = open(...)?

• A) It makes the code run faster
• B) It allows reading and writing simultaneously
• C) It guarantees the file is closed, even if an error occurs
• D) It automatically detects the file encoding

4. What does f.readlines() return?

• A) A single string containing the entire file
• B) A list of strings, one per line, with newline characters included
• C) A list of strings, one per line, with newline characters stripped
• D) A generator that yields one line at a time

5. Which pathlib operation joins path components in a cross-platform way?

• A) Path("dir") + "file.txt"
• B) Path("dir") / "file.txt"
• C) Path("dir").join("file.txt")
• D) Path.concat("dir", "file.txt")

6. When reading a CSV file in Python, why should you pass newline="" to open()?

• A) To make the file open faster
• B) To prevent Python's universal newline handling from interfering with the csv module
• C) To automatically strip newlines from each row
• D) To convert Windows line endings to Unix line endings

7. What is the difference between json.dump() and json.dumps()?

• A) dump() is for dictionaries; dumps() is for lists
• B) dump() writes to a file object; dumps() returns a string
• C) dump() is faster; dumps() is safer
• D) dump() uses compact format; dumps() uses pretty format

8. What Python type does None become when serialized to JSON and then deserialized back?

• A) The string "None"
• B) The integer 0
• C) Python None
• D) Python False

Section 2: True or False (1 point each)

9. write() automatically adds a newline at the end of the string you pass to it.

10. Iterating over a file object with for line in f: loads the entire file into memory.

11. csv.DictReader requires you to manually specify the column names.

12. Python tuples survive a JSON round-trip — if you dump a tuple and load it back, you get a tuple.

Section 3: Short Answer (2 points each)

13. You run this code and get an error:

with open("data/results.csv", "r") as f:
    content = f.read()

Error: FileNotFoundError: [Errno 2] No such file or directory: 'data/results.csv'

List three possible causes and one debugging technique.

14. Explain why this code is dangerous:

with open("important_data.txt", "w") as f:
    pass

15. What is the output of this code?

with open("test.txt", "w") as f:
    f.write("abc")
    f.write("def")

with open("test.txt", "r") as f:
    print(repr(f.read()))

'abcdef'

16. You have a CSV file with 10 million rows. Which approach is better and why?

# Approach A
with open("huge.csv", "r") as f:
    reader = csv.reader(f)
    data = list(reader)   # load everything

# Approach B
with open("huge.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        process(row)

Section 4: Code Writing (3 points each)

17. Write a function copy_file(source: str, destination: str) -> None that copies the contents of one text file to another. Use with statements.

def copy_file(source: str, destination: str) -> None:
    """Copy the contents of source to destination."""
    with open(source, "r") as src, open(destination, "w") as dst:
        for line in src:
            dst.write(line)

18. Write a function csv_average(filename: str, column: str) -> float that reads a CSV file and returns the average of the values in the specified column. Use csv.DictReader.

import csv

def csv_average(filename: str, column: str) -> float:
    """Return the average of a numeric column in a CSV file."""
    total = 0.0
    count = 0
    with open(filename, "r", newline="") as f:
        for row in csv.DictReader(f):
            total += float(row[column])
            count += 1
    return total / count

19. Write a function save_high_scores(scores: list[dict], filename: str) -> None that saves a list of score dictionaries to JSON, and a companion load_high_scores(filename: str) -> list[dict] that loads them back. Each score dict has "player" and "score" keys. load_high_scores should return an empty list if the file doesn't exist.

import json
from pathlib import Path

def save_high_scores(scores: list[dict], filename: str) -> None:
    """Save high scores to a JSON file."""
    with open(filename, "w") as f:
        json.dump(scores, f, indent=2)

def load_high_scores(filename: str) -> list[dict]:
    """Load high scores from JSON. Returns [] if file missing."""
    path = Path(filename)
    if not path.exists():
        return []
    with open(path, "r") as f:
        return json.load(f)

20. Write a program that reads sample-data.csv and produces a JSON file called employees.json where each employee is a dictionary with all their CSV fields plus a computed "weekly_pay" field. The JSON file should be an array of employee objects, pretty-printed.

import csv
import json

employees = []
with open("sample-data.csv", "r", newline="") as f:
    for row in csv.DictReader(f):
        row["weekly_pay"] = round(
            float(row["hours_worked"]) * float(row["hourly_rate"]), 2
        )
        employees.append(row)

with open("employees.json", "w") as f:
    json.dump(employees, f, indent=2)

print(f"Converted {len(employees)} employees to JSON.")