File Handling in Python

In Python, files on secondary storage are categorized into three distinct formats:

• Text Files (`.txt`): Stored as a sequence of human-readable ASCII or UTF-8 encoded characters. Each line terminates with an End-of-Line (EOL) character (usually `\n` on Linux/macOS, `\r\n` on Windows), which Python automatically translates to standard `\n`.
• Binary Files (`.dat`, `.bin`): Raw binary byte streams directly mirroring memory representations without character translation or EOL delimiters. Used for images, audio, compiled executables, and serialized Python objects.
• CSV Files (`.csv`): Comma-Separated Values text files storing tabular records where fields are delimited by commas (or tabs/semicolons).

The Complete File Access Modes Matrix

The Modern Standard: Context Manager (`with open()`)

Never call raw `f.close()` in production code. The with open() as f: context manager automatically closes the file and flushes OS buffers even if an unhandled exception or return occurs:

# Writing to a text file:
with open("students.txt", "w", encoding="utf-8") as f:
    f.write("Roll,Name,Marks\n")
    f.writelines(["1,Aarav,95\n", "2,Sneha,98\n", "3,Rohan,88\n"])

# Reading methods comparison:
with open("students.txt", "r", encoding="utf-8") as f:
    # 1. f.read(n): Reads n characters (or all characters if n omitted)
    # 2. f.readline(): Reads a single line including the '\n'
    # 3. f.readlines(): Reads all lines into a LIST of strings
    lines = f.readlines()
    print(lines) # ['Roll,Name,Marks\n', '1,Aarav,95\n', ...]

Manipulating the File Pointer: `tell()` and `seek()`

• `f.tell()`: Returns the current byte offset of the file pointer from the beginning of the file.
• `f.seek(offset, whence=0)`: Moves the file pointer to a new position:
  • `whence = 0` (Default): `offset` is calculated from the beginning of the file (SEEK_SET).
  • `whence = 1`: `offset` is relative to the current pointer position (SEEK_CUR) (binary files only!).
  • `whence = 2`: `offset` is relative to the end of the file (SEEK_END) (e.g., `f.seek(0, 2)` jumps to end).

Pickling (Serialization): Converting a live in-memory Python object hierarchy (list, dictionary, custom class) into a raw byte stream for storage on disk. Unpickling (Deserialization): Reconstructing the original Python object from the byte stream.

Complete Binary File Read-Write Template with `EOFError` Handling:

import pickle

# Writing serialized student records:
records = [
    {"roll": 101, "name": "Aarav", "marks": 94.5},
    {"roll": 102, "name": "Sneha", "marks": 98.0}
]
with open("students.dat", "wb") as f:
    for rec in records:
        pickle.dump(rec, f)

# Reading serialized binary records sequentially:
with open("students.dat", "rb") as f:
    try:
        while True:
            student = pickle.load(f)  # Unpickles next object
            print(f"Roll: {student['roll']} | Name: {student['name']} | Marks: {student['marks']}")
    except EOFError:
        # Standard idiom: pickle.load() raises EOFError when file ends!
        print("End of binary file reached successfully.")

Python's built-in csv library standardizes reading and writing comma-separated tabular files:

import csv

# Writing to CSV (newline='' prevents blank lines on Windows!):
with open("scores.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f, delimiter=",")
    writer.writerow(["Roll", "Name", "Physics", "Chemistry"])  # Header
    writer.writerows([
        [101, "Aarav", 95, 92],
        [102, "Sneha", 98, 96]
    ])

# Reading from CSV:
with open("scores.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row) # ['101', 'Aarav', '95', '92'] (Each row is a list of strings!)