File Handling in Python: A Complete Guide

import os

os.makedirs("file_handling_demo", exist_ok=True)

with open("file_handling_demo/learn.txt", "w", encoding="utf-8") as f:
    f.write("Day 1: Started learning Python file handling!\n")
    f.write("Day 2: Understood the 'with' statement. Life changing!\n")
    f.write("Day 3: Read and wrote my first CSV file like a data scientist!\n")

print("Sample files created successfully!")

file_object = open(filename, mode, encoding)

f = open("file_handling_demo/learn.txt", "r", encoding="utf-8")
print("File opened successfully!")
print("Type of file object:", type(f))
f.close()

f = open("file_handling_demo/learn.txt", "r", encoding="utf-8")
print("'r'  readable:", f.readable(), "| writable:", f.writable())
f.close()

f = open("file_handling_demo/temp_w.txt", "w", encoding="utf-8")
print("'w'  readable:", f.readable(), "| writable:", f.writable())
f.close()

f = open("file_handling_demo/temp_a.txt", "a", encoding="utf-8")
print("'a'  readable:", f.readable(), "| writable:", f.writable())
f.close()

f = open("file_handling_demo/learn.txt", "r+", encoding="utf-8")
print("'r+' readable:", f.readable(), "| writable:", f.writable())
f.close()

try:
    f = open("file_handling_demo/brand_new.txt", "x", encoding="utf-8")
    f.write("I am a brand new file!\n")
    f.close()
    print("'x' mode: file created successfully!")
except FileExistsError:
    print("'x' mode: file already exists, creation failed (as expected)!")

f = open("file_handling_demo/learn.txt", "r", encoding="utf-8")
content = f.read()
f.close()
print("File closed:", f.closed)

try:
    f = open("file_handling_demo/learn.txt", "r", encoding="utf-8")
    content = f.read()
finally:
    f.close()
print("File closed:", f.closed)

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    content = f.read()
# File is automatically closed here, no matter what!

print("File closed:", f.closed)

with open("file_handling_demo/shopping_list.txt", "w", encoding="utf-8") as f:
    f.write("My Shopping List:\n")
    f.write("1. Milk\n")
    f.write("2. Eggs\n")
    f.write("3. Bread\n")
    f.write("4. Coffee (the most important one)\n")

with open("file_handling_demo/shopping_list.txt", "r", encoding="utf-8") as f:
    print(f.read())

students = [
    "Alice's Score: 95\n",
    "Bob's Score: 87\n",
    "Carol's Score: 92\n",
    "Dave's Score: 78\n",
    "Eve's Score: 99\n",
]

with open("file_handling_demo/students.txt", "w", encoding="utf-8") as f:
    f.write("Student Scores:\n")
    f.writelines(students)

with open("file_handling_demo/students.txt", "r", encoding="utf-8") as f:
    print(f.read())

with open("file_handling_demo/shopping_list.txt", "a", encoding="utf-8") as f:
    f.write("5. Chocolate\n")
    f.write("6. Pizza\n")

with open("file_handling_demo/shopping_list.txt", "r", encoding="utf-8") as f:
    print(f.read())

import datetime

def write_log(log_file, level, message):
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    entry = f"[{timestamp}] [{level:7s}] {message}\n"
    with open(log_file, "a", encoding="utf-8") as f:
        f.write(entry)

log_path = "file_handling_demo/app.log"

write_log(log_path, "INFO",    "Server started on port 8080")
write_log(log_path, "INFO",    "User 'alice@gmail.com' logged in")
write_log(log_path, "WARNING", "Response time exceeded 500ms for /api/search")
write_log(log_path, "ERROR",   "Database connection timeout, retrying...")
write_log(log_path, "INFO",    "Database reconnected successfully")

with open(log_path, "r", encoding="utf-8") as f:
    print(f.read())

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    first_10 = f.read(10)
    next_10 = f.read(10)
    print(f"First 10 characters: {repr(first_10)}")
    print(f"Next 10 characters:  {repr(next_10)}")

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    line1 = f.readline()
    line2 = f.readline()
    line3 = f.readline()
    line4 = f.readline()   # Empty string = end of file
    print("Line 1:", repr(line1))
    print("Line 4 (EOF):", repr(line4))

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print("Type:", type(lines))
    print("Number of lines:", len(lines))

print("First entry:", lines[0].strip())
print("Last entry:", lines[-1].strip())

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    for line_num, line in enumerate(f, 1):
        line = line.strip()
        if line:
            print(f"  Entry {line_num}: {line}")

watch_history = [
    "alice,Stranger Things,S01E01,45:30,2024-01-15\n",
    "alice,Stranger Things,S01E02,50:22,2024-01-15\n",
    "alice,The Crown,S01E01,58:10,2024-01-16\n",
    "bob,Breaking Bad,S01E01,47:00,2024-01-15\n",
    "bob,Breaking Bad,S01E02,48:30,2024-01-16\n",
    "carol,Money Heist,S01E01,42:15,2024-01-17\n",
    "alice,Breaking Bad,S01E01,47:00,2024-01-17\n",
]

with open("file_handling_demo/watch_history.txt", "w", encoding="utf-8") as f:
    f.writelines(watch_history)

user_shows = {}
with open("file_handling_demo/watch_history.txt", "r", encoding="utf-8") as f:
    for line in f:
        parts = line.strip().split(",")
        user, show = parts[0], parts[1]
        if user not in user_shows:
            user_shows[user] = set()
        user_shows[user].add(show)

for user, shows in user_shows.items():
    print(f"  {user}: {', '.join(sorted(shows))}")

with open("file_handling_demo/learn.txt", "r", encoding="utf-8") as f:
    print("Starting position:", f.tell())        # 0 at the beginning

    first_line = f.readline()
    print("After reading line 1:", f.tell())      # Moved forward!

    second_line = f.readline()
    print("After reading line 2:", f.tell())

    f.seek(0)                                       # Back to the very beginning
    print("After seek(0):", f.tell())

    line_again = f.readline()
    print("Line 1 again:", repr(line_again))

    f.seek(7)                                        # Skip "Day 1: " (7 characters)
    print("After seek(7):", repr(f.read(8)))

with open("file_handling_demo/learn.txt", "r+", encoding="utf-8") as f:
    print(f"  .name       : {f.name}")
    print(f"  .mode       : {f.mode}")
    print(f"  .closed     : {f.closed}")
    print(f"  .readable() : {f.readable()}")
    print(f"  .writable() : {f.writable()}")
    print(f"  .seekable() : {f.seekable()}")

print(f"After 'with' block, .closed: {f.closed}")

import os

os.mkdir("file_handling_demo/reports")

# makedirs() creates every missing intermediate directory in one call
os.makedirs("file_handling_demo/archive/2026/january", exist_ok=True)

try:
    os.makedirs("file_handling_demo/reports", exist_ok=False)
except FileExistsError as e:
    print(f"Confirmed: {e}")

with open("file_handling_demo/old_name.txt", "w") as f:
    f.write("I will be renamed!\n")

os.rename("file_handling_demo/old_name.txt", "file_handling_demo/new_name.txt")
print("Old name exists:", os.path.exists("file_handling_demo/old_name.txt"))
print("New name exists:", os.path.exists("file_handling_demo/new_name.txt"))

if os.path.exists("file_handling_demo/new_name.txt"):
    os.remove("file_handling_demo/new_name.txt")
    print("File removed safely!")

os.rmdir("file_handling_demo/reports")
print("Empty directory removed!")

file_path = "file_handling_demo/learn.txt"

print(f"  exists()   : {os.path.exists(file_path)}")
print(f"  isfile()   : {os.path.isfile(file_path)}")
print(f"  getsize()  : {os.path.getsize(file_path)} bytes")
print(f"  basename() : {os.path.basename(file_path)}")
print(f"  dirname()  : {os.path.dirname(file_path)}")

safe_path = os.path.join("file_handling_demo", "reports", "summary.txt")
print(f"os.path.join(): {safe_path}")

os.path.join("folder", "subfolder", "file.txt")

Path("folder") / "subfolder" / "file.txt"

from pathlib import Path

p = Path("file_handling_demo/learn.txt")

print(f"  Path object : {p}")
print(f"  .name       : {p.name}")          # filename with extension
print(f"  .stem       : {p.stem}")          # filename without extension
print(f"  .suffix     : {p.suffix}")        # just the extension
print(f"  .parent     : {p.parent}")        # parent directory
print(f"  .exists()   : {p.exists()}")
print(f"  .stat().st_size: {p.stat().st_size} bytes")

base = Path("file_handling_demo")
log_path = base / "logs" / "server.log"
print(f"Joined path: {log_path}")

print("All .txt files in file_handling_demo/:")
for txt_file in Path("file_handling_demo").glob("*.txt"):
    print(f"  {txt_file.name}")

p = Path("file_handling_demo/pathlib_test.txt")

p.write_text("Hello from pathlib!\nNo open() needed!\n", encoding="utf-8")
content = p.read_text(encoding="utf-8")
print(content)

new_dir = Path("file_handling_demo/pathlib_dir")
new_dir.mkdir(exist_ok=True)

p.unlink()          # Delete the file
new_dir.rmdir()     # Remove the directory
print("Cleaned up!")

import csv

employees = [
    ["Name", "Department", "Salary", "Years"],
    ["Alice Johnson", "Engineering", 95000, 5],
    ["Bob Smith", "Marketing", 72000, 3],
    ["Carol White", "Engineering", 105000, 8],
    ["Dave Brown", "HR", 65000, 2],
    ["Eve Davis, PhD", "Research", 115000, 10],
]

with open("file_handling_demo/employees.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(employees)

with open("file_handling_demo/employees.csv", "r", encoding="utf-8") as f:
    print(f.read())

with open("file_handling_demo/employees.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)
    print(f"Columns: {header}")
    for row in reader:
        name, dept, salary, years = row
        print(f"  {name:<15} | {dept:<11} | ${int(salary):>7,} | {years} yrs")

total_salary = 0
engineers = []

with open("file_handling_demo/employees.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"  {row['Name']}: {row['Department']} (${int(row['Salary']):,})")
        total_salary += int(row["Salary"])
        if row["Department"] == "Engineering":
            engineers.append(row["Name"])

print(f"\nTotal salary bill: ${total_salary:,}")
print(f"Engineers: {', '.join(engineers)}")

new_employees = [
    {"Name": "Frank Lee", "Department": "Engineering", "Salary": 98000, "Years": 4},
    {"Name": "Grace Kim", "Department": "Design", "Salary": 82000, "Years": 6},
]
fieldnames = ["Name", "Department", "Salary", "Years"]

with open("file_handling_demo/new_employees.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(new_employees)

with open("file_handling_demo/new_employees.csv", "r", encoding="utf-8") as f:
    print(f.read())

import csv
from collections import defaultdict

orders = [
    ["order_id", "customer", "product", "category", "price", "quantity"],
    ["A001", "Alice", "Python Book", "Books", 29.99, 2],
    ["A002", "Bob", "Wireless Mouse", "Electronics", 45.00, 1],
    ["A003", "Alice", "Coffee Maker", "Appliances", 89.99, 1],
    ["A004", "Carol", "Python Book", "Books", 29.99, 3],
    ["A005", "Bob", "Keyboard", "Electronics", 75.00, 1],
    ["A006", "Dave", "Coffee Maker", "Appliances", 89.99, 2],
    ["A007", "Alice", "Headphones", "Electronics", 120.00, 1],
]

with open("file_handling_demo/orders.csv", "w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows(orders)

revenue_by_category = defaultdict(float)
orders_by_customer = defaultdict(int)

with open("file_handling_demo/orders.csv", "r", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        revenue = float(row["price"]) * int(row["quantity"])
        revenue_by_category[row["category"]] += revenue
        orders_by_customer[row["customer"]] += 1

print("Revenue by Category:")
for cat, rev in sorted(revenue_by_category.items(), key=lambda x: -x[1]):
    print(f"  {cat:<15}: ${rev:>8.2f}")

print("\nOrders by Customer:")
for customer, count in sorted(orders_by_customer.items()):
    print(f"  {customer:<10}: {count} orders")

import json

user_profile = {
    "username": "alice_wonder",
    "email": "alice@example.com",
    "age": 28,
    "premium": True,
    "watch_history": ["Stranger Things", "The Crown", "Breaking Bad"],
    "settings": {"autoplay": True, "quality": "4K", "language": "English"},
    "last_login": None
}

with open("file_handling_demo/user_profile.json", "w", encoding="utf-8") as f:
    json.dump(user_profile, f, indent=4)   # indent=4 makes it easy to read

with open("file_handling_demo/user_profile.json", "r", encoding="utf-8") as f:
    print(f.read())

with open("file_handling_demo/user_profile.json", "r", encoding="utf-8") as f:
    loaded_profile = json.load(f)

print(f"'premium' is type: {type(loaded_profile['premium'])}")   # bool, not string
print(f"'age' is type: {type(loaded_profile['age'])}")           # int, not string

data = {"name": "Bob", "scores": [95, 87, 92], "passed": True}

json_string = json.dumps(data)
print(json_string)

pretty = json.dumps(data, indent=2, sort_keys=True)
print(pretty)

api_response = '{"status": "ok", "results": 42, "data": [1, 2, 3]}'
parsed = json.loads(api_response)
print(f"Status: {parsed['status']}")

import json
import os

SETTINGS_FILE = "file_handling_demo/spotify_settings.json"

DEFAULT_SETTINGS = {
    "audio": {"quality": "high", "normalize": True, "equalizer": "flat"},
    "ui": {"theme": "dark", "language": "en", "show_lyrics": True},
    "social": {"share_activity": False, "follow_artists": True}
}

def load_settings():
    if os.path.exists(SETTINGS_FILE):
        with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    return DEFAULT_SETTINGS.copy()

def save_settings(settings):
    with open(SETTINGS_FILE, "w", encoding="utf-8") as f:
        json.dump(settings, f, indent=4)

def update_setting(settings, section, key, value):
    settings[section][key] = value
    return settings

settings = load_settings()
print(f"Theme   : {settings['ui']['theme']}")

settings = update_setting(settings, "ui", "theme", "light")
settings = update_setting(settings, "audio", "quality", "ultra")
save_settings(settings)

reloaded = load_settings()
print(f"After reload, theme: {reloaded['ui']['theme']}")
print(f"After reload, quality: {reloaded['audio']['quality']}")

try:
    with open("file_handling_demo/ghost_file.txt", "r") as f:
        content = f.read()
except FileNotFoundError as e:
    print(f"Caught: {e}")

# Write a file using latin-1 encoding, then try to read it back as ascii
with open("file_handling_demo/encoding_test.txt", "w", encoding="latin-1") as f:
    f.write("Café and naïve")

try:
    with open("file_handling_demo/encoding_test.txt", "r", encoding="ascii") as f:
        content = f.read()
except UnicodeDecodeError as e:
    print(f"Caught: {type(e).__name__}")
    # The fix: use the encoding the file was actually written with
    with open("file_handling_demo/encoding_test.txt", "r", encoding="latin-1") as f:
        print(f"Fixed. Content: {f.read()}")

import shutil, os

# Copy a single file
shutil.copy("file_handling_demo/learn.txt", "file_handling_demo/learn_backup.txt")
print("Backup exists:", os.path.exists("file_handling_demo/learn_backup.txt"))
print("Original still exists:", os.path.exists("file_handling_demo/learn.txt"))

# Move that backup into its own folder
os.makedirs("file_handling_demo/backups", exist_ok=True)
shutil.move("file_handling_demo/learn_backup.txt", "file_handling_demo/backups/learn_backup.txt")
print("Moved to backups/:", os.path.exists("file_handling_demo/backups/learn_backup.txt"))
print("Old location gone:", not os.path.exists("file_handling_demo/learn_backup.txt"))

# Copy the entire backups/ folder, contents and all, in one call
shutil.copytree("file_handling_demo/backups", "file_handling_demo/backups_copy")
print("Copied folder contents:", os.listdir("file_handling_demo/backups_copy"))

# os.rmdir() refuses to remove a non-empty folder
try:
    os.rmdir("file_handling_demo/backups_copy")
except OSError as e:
    print(f"os.rmdir() fails on a non-empty folder: {e}")

# shutil.rmtree() removes it anyway, contents and all
shutil.rmtree("file_handling_demo/backups_copy")
print("Removed even though it had files in it:", not os.path.exists("file_handling_demo/backups_copy"))

import shutil, os

def organize_by_extension(folder):
    for filename in os.listdir(folder):
        filepath = os.path.join(folder, filename)
        if os.path.isfile(filepath):
            ext = filename.split(".")[-1].upper()
            dest_folder = os.path.join(folder, f"{ext}_files")
            os.makedirs(dest_folder, exist_ok=True)
            shutil.move(filepath, os.path.join(dest_folder, filename))

organize_by_extension("file_handling_demo/downloads")

for root, dirs, files in os.walk("file_handling_demo/downloads"):
    for name in files:
        print(os.path.join(root, name))

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

f.read()          # Entire file as a string
f.read(n)         # Next n characters
f.readline()      # One line at a time
f.readlines()     # All lines as a list
for line in f:    # Best for large files, memory-efficient
    ...

f.write("text")          # Write a string (no automatic newline)
f.writelines(list)       # Write a list of strings (no automatic newlines)

f.tell()           # Current cursor position (bytes)
f.seek(0)          # Jump to the beginning
f.seek(0, 2)       # Jump to the end

os.getcwd()                             # Current directory
os.listdir("path")                      # List directory contents
os.makedirs("a/b/c", exist_ok=True)     # Create nested directories
os.rename("old", "new")                 # Rename a file or directory
os.remove("file.txt")                   # Delete a file
os.path.exists("path")                  # Check if a path exists
os.path.join("a", "b", "c")            # Build a safe, cross-platform path

from pathlib import Path
p = Path("folder") / "subfolder" / "file.txt"
p.read_text(encoding="utf-8")
p.write_text("content", encoding="utf-8")
p.exists(), p.is_file(), p.is_dir()
list(p.parent.glob("*.txt"))

import shutil
shutil.copy("src.txt", "dst.txt")       # Copy one file
shutil.move("src.txt", "dst.txt")       # Move or rename
shutil.copytree("src_dir", "dst_dir")   # Copy an entire directory
shutil.rmtree("dir")                    # Delete a directory, even non-empty

import csv
with open("data.csv") as f:
    for row in csv.reader(f): ...          # rows as lists
    for row in csv.DictReader(f): ...      # rows as dicts

with open("data.csv", "w", newline="") as f:
    csv.writer(f).writerows(data)          # from lists
    w = csv.DictWriter(f, fieldnames=[...])
    w.writeheader(); w.writerows(data)     # from dicts

import json
json.dump(data, file, indent=4)    # Python → JSON file
json.load(file)                     # JSON file → Python
json.dumps(data)                    # Python → JSON string
json.loads(string)                  # JSON string → Python