Reading and Writing Files in Python — The Complete Practical Guide

import os

# --- Demonstrate all four primary file modes ---

log_file_path = "app_events.log"

# MODE 'w': Write mode — creates the file fresh every time.
# WARNING: If app_events.log already existed, its content is now gone.
with open(log_file_path, "w") as log_file:
    log_file.write("[INFO] Application started\n")
    log_file.write("[INFO] Loading configuration\n")
print("Step 1 — Written initial log entries.")

# MODE 'a': Append mode — adds to the END without touching existing lines.
# Safe to call multiple times; previous content is always preserved.
with open(log_file_path, "a") as log_file:
    log_file.write("[INFO] User logged in: alice@example.com\n")
print("Step 2 — Appended a new log entry.")

# MODE 'r': Read-only mode — safest for reading; raises FileNotFoundError
# if the file doesn't exist, which protects you from silent failures.
with open(log_file_path, "r") as log_file:
    full_contents = log_file.read()  # reads the entire file as one string
print("Step 3 — Full log file contents:")
print(full_contents)

# MODE 'r+': Read + Write — cursor starts at position 0.
# Useful when you need to read, then update a value in the same session.
with open(log_file_path, "r+") as log_file:
    first_line = log_file.readline()   # reads just the first line
    print(f"Step 4 — First log entry: {first_line.strip()}")
    log_file.write("[DEBUG] r+ mode appends after current cursor position\n")

# Clean up the demo file so this script is safe to re-run
os.remove(log_file_path)
print("Step 5 — Demo file removed.")

# --- The RIGHT way vs the RISKY way to handle files ---

config_path = "server_config.txt"

# First, create a sample config file to work with
with open(config_path, "w") as config_file:
    config_file.write("host=localhost\n")
    config_file.write("port=8080\n")
    config_file.write("debug=True\n")


# ❌ THE RISKY WAY — manual open/close
# If an exception fires between open() and close(), close() never runs.
def read_config_risky(filepath):
    config_file = open(filepath, "r")          # file is now open
    raw_content = config_file.read()           # what if THIS raises an error?
    config_file.close()                        # this line might never execute
    return raw_content


# ✅ THE SAFE WAY — context manager guarantees cleanup
# The file is closed the instant the 'with' block ends, no matter what.
def read_config_safe(filepath):
    with open(filepath, "r") as config_file:  # __enter__ opens the file
        raw_content = config_file.read()       # reads all content at once
    # config_file.__exit__ has already been called — file is 100% closed here
    return raw_content


# ✅ PARSING CONFIG — turning raw text into a usable dictionary
def parse_config(filepath):
    settings = {}
    with open(filepath, "r") as config_file:
        for line in config_file:               # iterates line-by-line (memory efficient)
            line = line.strip()                # removes leading/trailing whitespace and \n
            if "=" in line:                    # skip blank lines or malformed entries
                key, value = line.split("=", 1)  # maxsplit=1 protects values containing "="
                settings[key] = value
    return settings


raw = read_config_safe(config_path)
print("Raw file content:")
print(raw)

parsed = parse_config(config_path)
print("Parsed config dictionary:")
for setting_key, setting_value in parsed.items():
    print(f"  {setting_key} → {setting_value}")

# Clean up
import os
os.remove(config_path)

import os

sales_data_path = "quarterly_sales.csv"

# Create a realistic sample CSV file
with open(sales_data_path, "w") as sales_file:
    sales_file.write("date,product,units_sold,revenue\n")
    sales_file.write("2024-01-15,Widget Pro,120,2400.00\n")
    sales_file.write("2024-01-22,Widget Pro,95,1900.00\n")
    sales_file.write("2024-02-03,Gadget Plus,200,6000.00\n")
    sales_file.write("2024-02-18,Widget Pro,150,3000.00\n")
    sales_file.write("2024-03-07,Gadget Plus,175,5250.00\n")


# STRATEGY 1: read() — entire file as one string
# Best for: small files, templates, hashing file contents
with open(sales_data_path, "r") as sales_file:
    entire_content = sales_file.read()
print("=== Strategy 1: read() ===")
print(f"Type: {type(entire_content)}, Characters: {len(entire_content)}")
print()


# STRATEGY 2: readlines() — list of line strings (newlines included)
# Best for: when you need line numbers or random access by index
with open(sales_data_path, "r") as sales_file:
    all_lines = sales_file.readlines()         # ["date,product,...\n", "2024-01-15,...\n", ...]
print("=== Strategy 2: readlines() ===")
print(f"Type: {type(all_lines)}, Line count: {len(all_lines)}")
print(f"Line at index 2: {all_lines[2].strip()}")  # .strip() removes the trailing \n
print()


# STRATEGY 3: Line-by-line iteration — memory efficient for large files
# Best for: data processing, filtering rows, aggregation — use this by default
def calculate_total_revenue(filepath):
    total_revenue = 0.0
    with open(filepath, "r") as sales_file:
        next(sales_file)                        # skip the header row
        for data_line in sales_file:            # reads one line at a time — constant memory
            columns = data_line.strip().split(",")
            revenue_column = float(columns[3])  # index 3 is the 'revenue' column
            total_revenue += revenue_column
    return total_revenue

total = calculate_total_revenue(sales_data_path)
print("=== Strategy 3: Line-by-line iteration ===")
print(f"Total revenue across all sales: ${total:,.2f}")
print()


# writelines() DEMO — note: you must add your own newlines!
results_path = "revenue_summary.txt"
summary_lines = [
    "=== Q1 2024 Revenue Summary ===\n",  # \n must be explicit — writelines() won't add it
    f"Total Revenue: ${total:,.2f}\n",
    "Source: quarterly_sales.csv\n",
]
with open(results_path, "w") as results_file:
    results_file.writelines(summary_lines)     # writes each string in the list, no auto-newline

with open(results_path, "r") as results_file:
    print("=== Written summary file ===")
    print(results_file.read())

os.remove(sales_data_path)
os.remove(results_path)

import os
from datetime import datetime

TASKS_FILE = "my_tasks.txt"
COMPLETED_MARKER = "[DONE]"
PENDING_MARKER = "[TODO]"


def load_tasks(filepath):
    """Read all tasks from disk. Returns an empty list if file doesn't exist yet."""
    if not os.path.exists(filepath):            # first run — no file yet, that's fine
        return []
    tasks = []
    with open(filepath, "r") as task_file:
        for raw_line in task_file:              # memory-efficient line iteration
            stripped = raw_line.strip()
            if stripped:                        # ignore any blank lines in the file
                tasks.append(stripped)
    return tasks


def add_task(filepath, task_description):
    """Append a new task to the file. Uses 'a' mode — never overwrites existing tasks."""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
    task_entry = f"{PENDING_MARKER} [{timestamp}] {task_description}\n"
    with open(filepath, "a") as task_file:     # 'a' is safe — no data loss possible
        task_file.write(task_entry)
    print(f"  ✅ Added: '{task_description}'")


def complete_task(filepath, task_index):
    """Mark a task as done. Must rewrite the whole file — no way to edit a single line in place."""
    all_tasks = load_tasks(filepath)
    if task_index < 0 or task_index >= len(all_tasks):
        print(f"  ❌ No task at index {task_index}")
        return
    target_task = all_tasks[task_index]
    if COMPLETED_MARKER in target_task:
        print(f"  ⚠️  Task {task_index} is already complete.")
        return
    # Replace the TODO marker with DONE — read-modify-write pattern
    all_tasks[task_index] = target_task.replace(PENDING_MARKER, COMPLETED_MARKER, 1)
    with open(filepath, "w") as task_file:     # 'w' intentionally overwrites — we have all data in memory
        for updated_task in all_tasks:
            task_file.write(updated_task + "\n")
    print(f"  ✅ Marked task {task_index} as complete.")


def display_tasks(filepath):
    """Print all tasks with their index so the user knows what index to pass to complete_task."""
    all_tasks = load_tasks(filepath)
    if not all_tasks:
        print("  📋 No tasks yet.")
        return
    print("  📋 Current tasks:")
    for index, task_line in enumerate(all_tasks):
        print(f"    [{index}] {task_line}")


# --- Run a simulated session ---
print("--- Adding tasks ---")
add_task(TASKS_FILE, "Write unit tests for the payment module")
add_task(TASKS_FILE, "Review PR #47 from the backend team")
add_task(TASKS_FILE, "Update README with new API endpoints")

print("\n--- Current task list ---")
display_tasks(TASKS_FILE)

print("\n--- Completing task 1 ---")
complete_task(TASKS_FILE, 1)

print("\n--- Updated task list ---")
display_tasks(TASKS_FILE)

# Clean up demo file
os.remove(TASKS_FILE)
print("\n--- Demo complete. Task file removed. ---")