Python File Handling

1. What is File Handling in Python?

Why File Handling in Python is Important

Let us try to understand each mode explanation in simple words:

file = open("data.txt")
data = file.read()
file.close()

with open("data.txt") as f:
    data = f.read()

with open("notes.txt") as f:
    content = f.read()

b) Read File Line by Line

with open("big.log") as f:
    for line in f:
        process(line)

c) Read All Lines into a List

with open("data.txt") as f:
    lines = f.readlines()

with open("report.txt", "w") as f:
    f.write("Final Summary")

b) Appending to a File (Safe for Logs)

with open("app.log", "a") as f:
    f.write("User logged in\n")

from datetime import datetime

def save_report(data):
    with open("report.txt", "w", encoding="utf-8") as f:
        f.write("=== Daily Report ===\n")
        f.write(data + "\n")

def log_event(message):
    with open("app.log", "a", encoding="utf-8") as f:
        timestamp = datetime.now().isoformat()
        f.write(f"{timestamp} | {message}\n")

save_report("Total users processed: 110")
log_event("Report generated successfully")

Explanation:

8. Real-World Use Cases of Python File Handling

from datetime import datetime

def log_event(event):
    with open("app.log", "a", encoding="utf-8") as f:
        f.write(f"{datetime.now()} - {event}\n")

8.2 Machine Learning Output Storage

def save_prediction(value):
    with open("prediction.txt", "a") as f:
        f.write(str(value) + "\n")

from pathlib import Path
from datetime import datetime
LOG_FILE = Path("system.log")

def process_user_action(user_id, action):
    with open(LOG_FILE, "a", encoding="utf-8") as f:
        timestamp = datetime.now().isoformat()
        f.write(f"{timestamp} | {user_id} | {action}\n")

def read_logs():
    if not LOG_FILE.exists():
        return []

    with open(LOG_FILE, encoding="utf-8") as f:
        return f.readlines()

process_user_action(101, "LOGIN")
process_user_action(102, "UPLOAD")
print("Logs:")
print("".join(read_logs()))

Explanation:

In the above code, firstly we have imported the Path class (from the pathlib module) to define a log file in a safe, cross-platform way.

After that, we have defined a function called process_user_action() which opens the log file in append mode and also writes a timestamp entry without deleting old logs.

Next, we have defined a read_logs() function. It first checks whether the log file exists or not. If it exists, then it reads all stored log entries line by line and returns a list of strings.

In the last line, the join() method is used to join all log entries into a single readable output and print it.

This is how Python file handling is used in production systems for logging, tracking, and audit trails.

def process_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            handle(line)

from pathlib import Path
import os

def safe_write_file(filename, content):
    file_path = Path(filename)
    temp_file = file_path.with_suffix(".tmp")

    with open(temp_file, "w", encoding="utf-8") as f:
        f.write(content)

    os.replace(temp_file, file_path)

safe_write_file("report.txt", "Final Report Generated")

Explanation:

In the above program, the Path class is imported from the built-in pathlib module. After that, we have imported os, which is also a built-in Python module. It is used to swap files atomically and safely at the OS level.

Next, a function called safe_write_file() is defined that takes two arguments:

• filename – It is the name of the file we want to write to.

• content – It is the text or data we want to store in that file.

The next line converts the file name ("report.txt") into a Path object. After that, a temporary file name is created by replacing the original file’s extension with .tmp. So report.txt becomes report.tmp.

In the next line, the open() method is used to open the temporary file in write mode ("w") using UTF-8 encoding. The file will be closed automatically after the writing operation, even if an error occurs.

In the next line, f.write(content) writes the provided content into the temporary file.

Please note that till this point, we have not used the original file.

Then, os.replace(temp_file, file_path) replaces the original file with the temporary file. Please note that now the temporary file becomes the real file, and the old file is removed automatically.

All this happens in a single step, and it reduces the risk of file corruption.

In the last line, we call the safe_write_file() function and pass the following two values:

• "report.txt" as the target file

• "Final Report Generated" as the content

In brief, first text is written to report.tmp, and then it is safely moved to the report.txt file.

from pathlib import Path

path = Path("data.txt")

if path.exists():
    open(path)
else:
    print("File not found")

10.2 Removing (Deleting) a File

import os
from pathlib import Path

if Path("data.txt").exists():
    os.remove("data.txt")

10.3 Handling File Errors Safely

try:
    open("data.txt")
except FileNotFoundError:
    print("Missing File")

12. Common File Handling Mistakes

c) Ignoring Encoding

d) Loading Large Files into Memory

e) Hard-Coding Paths

14. FAQ - Python File Handling

15. Production-Ready Python File Handling – End-to-End Decision Flow

This flowchart illustrates how to make correct file-handling decisions in Python, from data storage choice to production reliability.

16. Final Summary