Files, Exceptions & Modules.

We can already create functions that summarize inventory records. Now those records will come from files, and real-world data can be missing, malformed or inconsistent. Learn how Python handles each stage while preserving an honest account of failed records.

• Read and write UTF-8 text with pathlib and with open(), choosing file modes intentionally.
• Process line-oriented logs and CSV records without confusing them with raw text splitting.
• Load and save JSON, distinguishing a parse error from an unexpected data structure.
• Handle expected failures with targeted except branches and meaningful warnings.
• Explain try, except, else and finally without suppressing unrelated errors.
• Organize code using standard-library imports, functions and the __main__ guard.
• Build a fictional inventory-to-report workflow and validate its output.
• Create a small helper .py file in the temporary filesystem and import it from another script.

About files in this lesson: The live Python editor uses a temporary, isolated browser filesystem. If you completed the optional local Python setup in Lesson 01, try these same exercises in your own practice folder and compare the file output. Files you create with open() stay inside that runtime—not on your laptop, and not in the JoeLearns server. Review the optional local Python setup → They are not durable downloads. Keep examples fictional, and never paste secrets or customer files.

Many automation scripts begin with a file: an exported device list, a ticket attachment, or a previously generated report. A path identifies that file within a filesystem, while the current working directory determines how relative paths are resolved. Python's pathlib.Path helps express paths across operating systems. Here the workbench uses a temporary browser-only virtual filesystem, not the files on your computer. Every example creates its own fictional sample so the lesson works without downloads.

from pathlib import Path
path = Path('devices.txt')
path.write_text('SW-01,online\nAP-02,offline\n', encoding='utf-8')
text = path.read_text(encoding='utf-8')
print(text.count('offline'))

Opening a file gives Python a handle that should be closed when the work is complete. A with block handles closing even when an exception interrupts processing. 'r' reads, 'w' creates or overwrites, 'a' appends and 'x' creates only if the file does not already exist. Accidentally using 'w' on an existing report can destroy its previous content. Use explicit modes and encodings, and consider temporary output and review before replacing important data on a real machine.

with open('sample.log', 'w', encoding='utf-8') as file:
    file.write('Start\n')
with open('sample.log', 'a', encoding='utf-8') as file:
    file.write('Complete\n')
with open('sample.log', 'r', encoding='utf-8') as file:
    print(file.read().strip())

A log file can contain thousands of lines. Calling read() loads its entire contents into one string, whereas iterating directly over a text file yields lines one at a time. A trailing newline is part of a line, so strip() or rstrip('\n') may be needed before comparing. Be careful: strip removes all surrounding whitespace, which might matter in structured data. For simple troubleshooting notes, line iteration is a useful first step toward stream processing.

with open('events.log', 'w', encoding='utf-8') as f:
    f.write('INFO online\nWARN offline\n')
alerts = []
with open('events.log', 'r', encoding='utf-8') as f:
    for line in f:
        if line.startswith('WARN'):
            alerts.append(line.rstrip('\n'))
print(alerts)

CSV often appears in exports from inventory, ticketing and monitoring tools. The standard csv module understands quoted commas and column boundaries that a naive split(',') does not. csv.DictReader uses the first row as column names and yields dictionaries for subsequent rows. Decide what to do with missing columns and blank values rather than silently treating them as healthy. When writing CSV, use newline='' so the module controls row delimiters, especially across operating systems.

import csv
from io import StringIO
sample = 'host,status\nSW-01,online\nAP-02,offline\n'
reader = csv.DictReader(StringIO(sample))
offline = [row['host'] for row in reader if row['status'] == 'offline']
print(offline)

APIs and configuration exports commonly represent data as JSON. json.loads() parses a JSON string; json.load() reads JSON from a file object. json.dumps() produces text; json.dump() writes to an open file. JSON objects become dictionaries, arrays become lists, and true/false/null become True/False/None. Invalid JSON raises json.JSONDecodeError. Never assume a successful parse means all expected keys or data types are present.

import json
raw = '{"site": "HQ", "devices": ["SW-01", "AP-02"]}'
record = json.loads(raw)
print(record['site'])
print(len(record['devices']))

Files can be missing, numeric fields can be invalid, and JSON can be malformed. Python raises exceptions when a normal operation cannot continue. Place only the operation likely to fail inside try, then catch a specific exception such as FileNotFoundError, ValueError or json.JSONDecodeError. A broad except: hides programming mistakes and can even intercept system-level signals. Logging an error is different from treating the failed record as valid; preserve the distinction.

values = ['443', 'N/A', '8080']
ports = []
for value in values:
    try:
        ports.append(int(value))
    except ValueError:
        print('Skipped invalid port:', value)
print(ports)

The else block of a try statement runs only when the try block finishes without an exception. The finally block runs when leaving the try statement, whether an exception was raised or not. Use else for operations dependent on successful parsing; use finally for cleanup that cannot use a context manager. A finally block does not erase an exception automatically, and return statements inside finally can accidentally mask failures. A with block remains the preferred way to close ordinary files.

try:
    port = int('N/A')
except ValueError:
    print('Invalid port')
else:
    print('Port:', port)
finally:
    print('Checked input')

A module is a Python file whose definitions can be imported by other files. The standard library already provides csv, json, pathlib and many other useful modules. import json keeps the module namespace clear; from pathlib import Path brings in a specific name. Imports execute top-level module code the first time a module is loaded, so keep reusable helpers separate from demo runs. The if __name__ == '__main__' guard lets a file run as a script without running its demo every time another module imports it.

import statistics

def average_latency(samples):
    return statistics.mean(samples)

if __name__ == '__main__':
    print(average_latency([20, 40, 60]))

A module does not have to come from the standard library: you can create your own file ending in .py and import its functions. A common arrangement is helpers.py for reusable logic and report.py for the entry-point script. In this temporary browser workspace, writing a .py file with pathlib lets you practice the same idea without installing an editor or creating anything on your computer. An import runs the module's top-level statements the first time it is loaded; keep demonstrations under a main guard.

from pathlib import Path
Path('status_helpers.py').write_text(
    "def is_offline(status):\n    return status.strip().lower() == 'offline'\n",
    encoding='utf-8'
)
import status_helpers
print(status_helpers.is_offline(' OFFLINE '))

A practical automation workflow reads structured records, validates fields, skips or reports malformed rows, builds a reliable summary, and writes a clear output artifact. Compose small helpers rather than one giant try block. Check required headers, preserve unknowns instead of reclassifying them, and only publish an output after confirming it is correct. This browser lesson uses fictional data and temporary virtual files, so it cannot overwrite anything on a learner's computer.

import csv, json
with open('inventory.csv', 'w', encoding='utf-8', newline='') as f:
    f.write('host,status\nSW-01,online\nAP-02,offline\n')
with open('inventory.csv', newline='', encoding='utf-8') as f:
    offline = sorted(r['host'] for r in csv.DictReader(f)
                     if r['status'] == 'offline')
report = {'offline_hosts': offline}
print(json.dumps(report, sort_keys=True))

Now execute actual Python. The first exercise creates a sample technician note for you. Read it using a context manager, inspect your variables and console output, then continue into writing, CSV, JSON, error handling, modules and a combined report in Practice.

Python's standard library documentation is worth bookmarking. It explains exact file behavior, exceptions, and how readers and writers handle structured formats.