🔐 File Handling in Python (Binary & CSV file)

🥒 Pickling, UnPickling & Structured Data Storage!

After text files, this chapter covers two more kinds of file. Binary files let you store any Python object directly (lists, dicts, class objects) and CSV files store structured tabular data that opens directly in a spreadsheet such as Excel.

5.5.1

Binary File Basics

Creating, opening and closing binary files with the right modes

wbrbabrb+

5.5.2

Pickling

Serialize any Python object and write it to a binary file

pickle.dump()

5.5.3

UnPickling

Deserialize and restore Python objects back from binary files

pickle.load()

5.5.4

Searching

Find specific records by looping through a binary file

EOFErrorloop

5.5.5

Updating

Modify records using the Read-All → Modify → Write-All pattern

updaterewrite

5.6

CSV Files

Read and write structured comma-separated tabular data

csv modulereaderwriter

🔒 5.5 Working with Binary Files

What Makes Binary Files Special?

Text files are great for storing simple strings — but what if you want to save a complete Python dictionary, a list of student records, or even a custom class object directly to disk? That's where binary files shine!

Binary files store data in the same format as Python's internal memory (RAM) representation — raw bytes. This means:

✅ Any Python object can be stored — lists, dicts, tuples, class instances
✅ No data type conversion needed (text files force everything into strings)
✅ Faster for complex, structured records
❌ Not human-readable — you need Python to open and decode them

🧠 Memory Trick

Text files are like writing a letter in English — anyone can read it. Binary files are like a WhatsApp voice note stored as bytes — only the app (Python) can decode and play it back! 🎤

🎁 The `pickle` Module

Python handles all binary file serialization through the built-in pickle module. It converts Python objects into a byte stream (and reconstructs them back perfectly).

🔑 Two core pickle functions

pickle.dump(object, file) → Serialize and write object to binary file
pickle.load(file) → Read from binary file and reconstruct back to Python object

The conversion Python object → bytes is called Pickling (Serialization). The reverse, bytes → Python object, is called UnPickling (Deserialization).

🗺️ Pickling & UnPickling — The Full Picture

🥒 Pickling — Writing to Binary File

flowchart LR
    A["🐍 Python Object\nlist / dict / object"]
    B["open() with 'wb'\nOpen file for writing"]
    C["pickle.dump()\nSerialize to bytes"]
    D["💾 Binary File\nstudents.dat"]

    A --> B --> C --> D

    classDef tryNode fill:none;
    classDef elseNode fill:none;
    classDef normalNode fill:none;

    class A elseNode;
    class B,C tryNode;
    class D normalNode;

📦 Unpickling — Reading from Binary File

flowchart LR
    D["💾 Binary File\nstudents.dat"]
    E["open() with 'rb'\nOpen file for reading"]
    F["pickle.load()\nDeserialize bytes"]
    G["🐍 Python Object\nRestored perfectly!"]

    D --> E --> F --> G

    classDef tryNode fill:none;
    classDef elseNode fill:none;
    classDef normalNode fill:none;

    class D normalNode;
    class E,F tryNode;
    class G elseNode;

🔑 5.5.1 Creating / Opening / Closing Binary Files

Binary files use the same open() function as text files — just add b to the mode string!

'wb' — Write Binary 📦
- Opens for writing in binary mode
- Creates new file if it doesn't exist
- Overwrites and destroys existing content (like 'w' in text mode) ⚠️
- Use for: Creating a fresh binary file from scratch
'rb' — Read Binary 📖
- Opens for reading in binary mode — file must exist!
- Raises FileNotFoundError if file is missing
- Use for: Reading, displaying, or searching records
'ab' — Append Binary ➕
- Opens for appending in binary mode
- Adds new data at the very end; preserves all existing records
- Use for: Adding new records without touching old ones
'rb+' — Read + Write Binary 🔀
- Opens for both reading and writing in binary mode
- File must already exist — does NOT create a new file
- Use for: Complex operations needing both read and write

📋 Board Exam Hotspot

Binary files in CBSE exams almost always use the .dat extension (e.g., students.dat). Python doesn't enforce this — it's just convention. Always import pickle at the top of any binary file program!

import pickle

# The standard pattern for binary file operations
f = open("students.dat", "wb")   # Open in binary write mode
# ... operations ...
f.close()                         # Always close!

🥒 5.5.2 Writing onto a Binary File — Pickling!

To write a Python object into a binary file, use pickle.dump(). You can dump dictionaries, lists, tuples, strings, numbers — literally any Python object.

🔑 Syntax

pickle.dump(object, file_object)

object → The Python object to serialize and store
file_object → File opened in 'wb' (new) or 'ab' (append) mode

import pickle

# Writing a single dictionary record
f = open("students.dat", "wb")
student = {"name": "Aman Sharma", "roll": 1, "marks": 95}
pickle.dump(student, f)
f.close()
print("Record written! ✅")

import pickle

# Writing MULTIPLE records — one dump per record!
students = [
    {"roll": 1, "name": "Aman Sharma",  "marks": 95},
    {"roll": 2, "name": "Priya Singh",  "marks": 88},
    {"roll": 3, "name": "Rohan Gupta",  "marks": 76},
    {"roll": 4, "name": "Sneha Joshi",  "marks": 92},
]

f = open("students.dat", "wb")
for student in students:
    pickle.dump(student, f)   # Each dict dumped separately!
f.close()
print(f"{len(students)} records written! ✅")

import pickle

# Appending a NEW record without losing existing data
f = open("students.dat", "ab")   # 'ab' = safe append
new_student = {"roll": 5, "name": "Kavya Reddy", "marks": 98}
pickle.dump(new_student, f)
f.close()
print("New student appended! ✅")

⚠ Common Mistake

When writing multiple records with pickle.dump() in a loop, each call writes one independent object. Don't dump a single giant list if you plan to update individual records later — dump them one by one so you can read them back one by one with pickle.load(). 🚨

💡 Study Strategy

Think of pickle.dump() like putting items into individual sealed courier parcels on a conveyor belt. Each object gets its own package. pickle.load() unpacks them one at a time from the other end! 📦

📦 5.5.3 Reading from a Binary File — UnPickling!

To retrieve data from a binary file, use pickle.load(). Each call reads exactly one object that was previously dumped — in the same order they were written.

🔑 Syntax

object = pickle.load(file_object)

file_object → File opened in 'rb' mode
Returns the next reconstructed Python object from the file
Raises EOFError when no more objects remain (end of file)

import pickle

# Reading a single record
f = open("students.dat", "rb")
student = pickle.load(f)
print(student)
# {'roll': 1, 'name': 'Aman Sharma', 'marks': 95}
f.close()

import pickle

# 🌟 Reading ALL records — The Standard CBSE Pattern
f = open("students.dat", "rb")
print("All Student Records:")
print("-" * 40)
while True:
    try:
        student = pickle.load(f)
        print(f"Roll: {student['roll']}  |  Name: {student['name']}  |  Marks: {student['marks']}")
    except EOFError:
        break      # No more records — exit the loop cleanly
f.close()

📋 Board Exam Hotspot

The EOFError (End of File Error) is how Python signals that all objects have been read. The pattern below is essential to memorize — it is used when reading a binary file record by record:

while True:
    try:
        record = pickle.load(f)
        # process record
    except EOFError:
        break

🧠 Memory Trick

dump() → Drop object Under disk's Memory Protection (write!)
load() → Lift Object And Deliver back (read!)

Together they're like a courier service — dump() ships the parcel, load() delivers it back to you! 🚚

🔍 5.5.4 Searching in a Binary File

Searching a binary file means reading records one by one and checking each against your criteria. There's no shortcut — you must read → compare → act for every record.

flowchart TD
    A["Open file\nin 'rb' mode"]
    B["pickle.load()\nRead one record"]
    C{"Record matches\nthe search criteria?"}
    D["✅ Found!\nDisplay / Process it"]
    E{"EOFError\nraised?"}
    F["❌ Record not found\nPrint message"]
    G["Close file"]

    A --> B
    B --> C
    C -->|"Yes — Match!"| D
    C -->|"No — Keep looking"| E
    D --> G
    E -->|"No — more records"| B
    E -->|"Yes — file ended"| F
    F --> G

    classDef normalNode fill:none;
    classDef elseNode fill:none;
    classDef exceptNode fill:none;
    classDef tryNode fill:none;

    class A normalNode;
    class B tryNode;
    class C normalNode;
    class D elseNode;
    class E normalNode;
    class F exceptNode;
    class G normalNode;

import pickle

# Search for a student by roll number
def search_student(roll_no):
    found = False
    try:
        f = open("students.dat", "rb")
        while True:
            try:
                student = pickle.load(f)
                if student["roll"] == roll_no:
                    print("\n✅ Student Found!")
                    print(f"  Name  : {student['name']}")
                    print(f"  Roll  : {student['roll']}")
                    print(f"  Marks : {student['marks']}")
                    found = True
                    break
            except EOFError:
                break
        f.close()
    except FileNotFoundError:
        print("Error: File not found!")

    if not found:
        print(f"❌ No student with roll {roll_no} found.")

search_student(3)

import pickle

# Search ALL students scoring above a cutoff (multiple matches)
def toppers(cutoff):
    print(f"\n🏆 Students with marks > {cutoff}:")
    print("-" * 35)
    count = 0
    f = open("students.dat", "rb")
    while True:
        try:
            s = pickle.load(f)
            if s["marks"] > cutoff:
                print(f"  {s['name']} — {s['marks']}")
                count += 1
        except EOFError:
            break
    f.close()
    print(f"\nTotal: {count} student(s)")

toppers(85)

💡 Study Strategy

Every binary file search follows the same 3-step skeleton — learn this pattern:

Open file in 'rb' mode
while True → try: pickle.load() → check condition → except EOFError: break
Close file

The only thing that changes between questions is the condition inside step 2!

✏️ 5.5.5 Updating in a Binary File

Unlike text files, you cannot edit a single record inside a pickle binary file directly — changing one record can shift byte positions and corrupt everything after it. The safe and standard CBSE approach is the Read-All → Modify → Write-All-Back pattern:

flowchart LR
    A["Step 1️⃣\nOpen 'rb'\nRead ALL records into a list"]
    B["Step 2️⃣\nFind & modify\nthe target record in the list"]
    C["Step 3️⃣\nOpen 'wb'\nOverwrite file with modified list"]
    D["✅ File Updated!"]

    A --> B
    B --> C
    C --> D

    classDef tryNode fill:none;
    classDef elseNode fill:none;
    classDef normalNode fill:none;

    class A tryNode;
    class B elseNode;
    class C tryNode;
    class D normalNode;

import pickle

def update_marks(roll_no, new_marks):
    # ── Step 1: Read ALL records into a Python list ──
    records = []
    try:
        f = open("students.dat", "rb")
        while True:
            try:
                records.append(pickle.load(f))
            except EOFError:
                break
        f.close()
    except FileNotFoundError:
        print("Error: File not found!")
        return

    # ── Step 2: Find and modify the target record ────
    updated = False
    for record in records:
        if record["roll"] == roll_no:
            print(f"Old marks for {record['name']}: {record['marks']}")
            record["marks"] = new_marks
            print(f"Updated marks: {record['marks']}")
            updated = True
            break

    if not updated:
        print(f"❌ Roll {roll_no} not found!")
        return

    # ── Step 3: Write ALL records back to file ───────
    f = open("students.dat", "wb")   # 'wb' overwrites completely
    for record in records:
        pickle.dump(record, f)
    f.close()
    print("✅ Record updated successfully!")

update_marks(2, 95)

import pickle

# Deleting a record — same Read-Modify-Write pattern!
def delete_student(roll_no):
    records = []
    f = open("students.dat", "rb")
    while True:
        try:
            rec = pickle.load(f)
            if rec["roll"] != roll_no:    # Keep ALL except the target
                records.append(rec)
        except EOFError:
            break
    f.close()

    f = open("students.dat", "wb")        # Rewrite without deleted record
    for rec in records:
        pickle.dump(rec, f)
    f.close()
    print(f"✅ Student with roll {roll_no} deleted!")

delete_student(3)

📋 Board Exam Hotspot

The update/delete pattern is an important exam pattern. Always follow:

'rb' → Read all → store in list
Modify the list in memory
'wb' → Write entire modified list back

Never attempt to overwrite a single record directly inside a pickle file! 🚨

⚠ Common Mistake

Students try to use 'rb+' mode thinking they can edit a specific record in place. Don't! Pickle records vary in size — overwriting one record shifts all byte positions and corrupts everything after it. Always use the read-all → modify → write-all approach! 🔥

🧩 Complete Binary File Program — All Operations

import pickle

FILENAME = "school.dat"

def create_records():
    students = [
        {"roll": 1, "name": "Aman Sharma",  "marks": 95, "grade": "A+"},
        {"roll": 2, "name": "Priya Singh",  "marks": 88, "grade": "A"},
        {"roll": 3, "name": "Rohan Gupta",  "marks": 76, "grade": "B+"},
        {"roll": 4, "name": "Sneha Joshi",  "marks": 92, "grade": "A+"},
        {"roll": 5, "name": "Kavya Reddy",  "marks": 65, "grade": "B"},
    ]
    f = open(FILENAME, "wb")
    for s in students:
        pickle.dump(s, f)
    f.close()
    print("✅ Records created!")

def display_all():
    f = open(FILENAME, "rb")
    print(f"\n{'Roll':<6} {'Name':<20} {'Marks':<8} {'Grade'}")
    print("-" * 42)
    while True:
        try:
            s = pickle.load(f)
            print(f"{s['roll']:<6} {s['name']:<20} {s['marks']:<8} {s['grade']}")
        except EOFError:
            break
    f.close()

def search_by_name(keyword):
    f = open(FILENAME, "rb")
    print(f"\n🔍 Searching for '{keyword}':")
    found = False
    while True:
        try:
            s = pickle.load(f)
            if keyword.lower() in s["name"].lower():
                print(f"  → Roll {s['roll']}: {s['name']} | Marks: {s['marks']}")
                found = True
        except EOFError:
            break
    f.close()
    if not found:
        print("  No match found!")

def update_grade(roll, new_grade):
    records = []
    f = open(FILENAME, "rb")
    while True:
        try:
            records.append(pickle.load(f))
        except EOFError:
            break
    f.close()
    for r in records:
        if r["roll"] == roll:
            r["grade"] = new_grade
    f = open(FILENAME, "wb")
    for r in records:
        pickle.dump(r, f)
    f.close()
    print(f"✅ Grade updated for roll {roll}")

# Run all operations
create_records()
display_all()
search_by_name("Singh")
update_grade(3, "A")
display_all()

📊 5.6 Working with CSV Files

What is a CSV File?

CSV stands for Comma-Separated Values. It's a universal, plain-text format for storing structured tabular data — just like an Excel spreadsheet, but in a simple .csv file.

Imagine this Excel table:

Name	Roll	Marks	Grade
Aman	1	95	A+
Priya	2	88	A

In CSV format, that exact same data becomes:

Name,Roll,Marks,Grade
Aman,1,95,A+
Priya,2,88,A

That's it! Just values separated by commas, one row per line.

🧠 Memory Trick

CSV = Commas Separating Values! Every row is one line, every column is a comma-separated value. The simplest possible table format — yet accepted by Excel, Google Sheets, MySQL, PostgreSQL, and practically every tool on Earth! 🌍

Why CSV over plain text files? 📄
- Structure → Data organized in rows and columns — not just random lines
- Universal → Every tool understands CSV: Excel, databases, Python, R, Java...
- Human-readable → Unlike binary, you can open and read it in Notepad
- Lightweight → No database software needed — just a .csv file!
- Perfect for → Student records, marks sheets, sales data, inventory, logs
Python's csv Module 🐍
- Built-in module — no installation needed (import csv)
- Handles commas inside values automatically using quoting
- csv.writer / csv.reader — list-based read/write
- csv.DictWriter / csv.DictReader — dictionary-based read/write (cleaner!)

🔑 Always import csv at the top

import csv

🔑 5.6.1 Opening / Closing CSV Files

CSV files are opened with the same open() function — with one critical extra argument:

🔑 The Standard CSV Opening Pattern

f = open("data.csv", "w", newline='')

The newline='' parameter is essential — it prevents Python from adding extra blank lines between rows (especially on Windows)!

Modes for CSV files 📝
- 'w' → Write (creates new / overwrites existing)
- 'r' → Read (file must exist)
- 'a' → Append (adds to end, preserves existing data)

import csv

# Writing — always newline=''
f = open("marks.csv", "w", newline='')
# ... write operations ...
f.close()

# Reading — good practice to include newline='' here too
f = open("marks.csv", "r", newline='')
# ... read operations ...
f.close()

# Best practice — with statement (auto-closes, cleaner!)
with open("marks.csv", "w", newline='') as f:
    pass   # operations here

⚠ Common Mistake

Forgetting newline='' when writing CSV on Windows inserts a blank line between every data row! This breaks the file structure and trips up every tool trying to read it. Always include newline='' — no exceptions! 🚨

✍️ 5.6.2 Writing in CSV Files

Two approaches — choose based on whether you're working with lists or dictionaries:

✏️ csv.writer + writerow() / writerows()
- Takes lists or tuples — each list is one row
- writerow(list) → Write a single row
- writerows(list_of_lists) → Write all rows at once — efficient!
📒 csv.DictWriter + writeheader() + writerow()
- Takes dictionaries — keys become column headers automatically
- writeheader() → Write the first row as column names
- writerow(dict) → Write one dict as one data row

Method 1 — `csv.writer` (List-based)

import csv

# writerow() — one row at a time
with open("students.csv", "w", newline='') as f:
    writer = csv.writer(f)

    writer.writerow(["Roll", "Name", "Marks", "Grade"])   # Header
    writer.writerow([1, "Aman Sharma",  95, "A+"])
    writer.writerow([2, "Priya Singh",  88, "A"])
    writer.writerow([3, "Rohan Gupta",  76, "B+"])

print("CSV written! ✅")
# File (students.csv):
# Roll,Name,Marks,Grade
# 1,Aman Sharma,95,A+
# 2,Priya Singh,88,A
# 3,Rohan Gupta,76,B+

import csv

# writerows() — write ALL rows in one efficient call!
with open("students.csv", "w", newline='') as f:
    writer = csv.writer(f)

    header = ["Roll", "Name", "Marks", "Grade"]
    data = [
        [1, "Aman Sharma",  95, "A+"],
        [2, "Priya Singh",  88, "A"],
        [3, "Rohan Gupta",  76, "B+"],
        [4, "Sneha Joshi",  92, "A+"],
        [5, "Kavya Reddy",  65, "B"],
    ]
    writer.writerow(header)     # Header first
    writer.writerows(data)      # All data in one go!

print("All records written with writerows()! ✅")

Method 2 — `csv.DictWriter` (Dictionary-based)

import csv

# DictWriter — cleaner, safer for complex data
with open("students.csv", "w", newline='') as f:

    fields = ["Roll", "Name", "Marks", "Grade"]
    writer = csv.DictWriter(f, fieldnames=fields)

    writer.writeheader()    # Writes: Roll,Name,Marks,Grade

    students = [
        {"Roll": 1, "Name": "Aman Sharma",  "Marks": 95, "Grade": "A+"},
        {"Roll": 2, "Name": "Priya Singh",  "Marks": 88, "Grade": "A"},
        {"Roll": 3, "Name": "Rohan Gupta",  "Marks": 76, "Grade": "B+"},
    ]
    for s in students:
        writer.writerow(s)

print("DictWriter done! ✅")

📋 Board Exam Tip

Board Exam Hotspot — `write` methods summary:	Method	Used With
`writerow(list)`	`csv.writer`	One row as a list
`writerows(list_of_lists)`	`csv.writer`	Multiple rows at once
`writeheader()`	`csv.DictWriter` only	Column names as first row
`writerow(dict)`	`csv.DictWriter`	One row as a dictionary

📖 5.6.3 Reading in CSV Files

Reading mirrors writing — two clean approaches:

📋 csv.reader — Reads each row as a list of strings
📒 csv.DictReader — Reads each row as a dictionary (first row = keys)

Method 1 — `csv.reader` (List-based)

import csv

# Basic reading — each row is a list
with open("students.csv", "r", newline='') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
# Output:
# ['Roll', 'Name', 'Marks', 'Grade']    ← header row (a list!)
# ['1', 'Aman Sharma', '95', 'A+']      ← all values are STRINGS!
# ['2', 'Priya Singh', '88', 'A']

import csv

# Skip header, then process data rows
with open("students.csv", "r", newline='') as f:
    reader = csv.reader(f)

    header = next(reader)    # Read and skip the header row
    print(f"Columns: {header}")

    for row in reader:
        roll  = int(row[0])     # ← Convert string to int!
        name  = row[1]
        marks = int(row[2])     # ← CSV gives strings — always convert!
        grade = row[3]
        print(f"Roll {roll}: {name} scored {marks} marks ({grade})")

Method 2 — `csv.DictReader` (Dictionary-based — Recommended!)

import csv

# DictReader — access columns by name, not index
with open("students.csv", "r", newline='') as f:
    reader = csv.DictReader(f)    # First row auto-becomes dict keys!

    for row in reader:
        # Access by column name — much cleaner than row[0], row[2]!
        print(f"{row['Name']} → Marks: {row['Marks']}, Grade: {row['Grade']}")

⚠ Common Mistake

csv.reader reads everything as strings — even numbers! 95 becomes '95'. Always convert:

marks = int(row[2])        # ✅ '95' → 95
price = float(row[3])      # ✅ '45.5' → 45.5

Forgetting this breaks any arithmetic and causes TypeError! 🚨

🧠 Memory Trick

csv.writer / csv.reader → Work with lists (access by position: row[0], row[1])
csv.DictWriter / csv.DictReader → Work with dicts (access by name: row['Name'], row['Marks'])

The Dict variants are cleaner, safer, and far more readable. Prefer them whenever possible!

✍️ CSV Write Operation — Visual Guide

flowchart LR
    A["🐍 Python Data\nLists / Dicts"]
    B["open() with\nnewline=''"]
    C["csv.writer\nor DictWriter"]
    D["writerow()\nwriterows()\nwriteheader()"]
    E["💾 CSV File\nstudents.csv"]

    A --> B --> C --> D --> E

    classDef dataNode fill:none;
    classDef fileNode fill:none;
    class A,E dataNode;
    class B,C,D fileNode;

📖 CSV Read Operation — Visual Guide

flowchart LR
    E["💾 CSV File\nstudents.csv"]
    F["open() with\nnewline=''"]
    G["csv.reader\nor DictReader"]
    H["for row in reader\nProcess each row"]
    I["✅ Restored Data\n(convert types!)"]

    E --> F --> G --> H --> I

    classDef dataNode fill:none;
    classDef fileNode fill:none;
    class E,I dataNode;
    class F,G,H fileNode;

🧩 Complete CSV Program — All Operations

import csv

FILENAME = "library.csv"
FIELDS = ["BookID", "Title", "Author", "Price", "Qty"]

def create_library():
    """Write initial records"""
    books = [
        [101, "Python Basics",          "Guido Van",    450, 15],
        [102, "Data Structures",        "Mark Allen",   620,  8],
        [103, "Computer Networks",      "Forouzan",     780, 12],
        [104, "DBMS Concepts",          "Korth",        590,  5],
        [105, "Artificial Intelligence","Russell",      850, 10],
    ]
    with open(FILENAME, "w", newline='') as f:
        writer = csv.writer(f)
        writer.writerow(FIELDS)      # Header
        writer.writerows(books)      # All data
    print("✅ Library CSV created!")

def display_all():
    """Read and display all books"""
    with open(FILENAME, "r", newline='') as f:
        reader = csv.DictReader(f)
        print(f"\n{'ID':<6} {'Title':<28} {'Author':<16} {'Price':>7} {'Qty':>5}")
        print("-" * 65)
        for row in reader:
            print(f"{row['BookID']:<6} {row['Title']:<28} {row['Author']:<16} ₹{row['Price']:>5} {row['Qty']:>5}")

def search_by_author(name):
    """Search books by author name"""
    print(f"\n📚 Books by '{name}':")
    found = False
    with open(FILENAME, "r", newline='') as f:
        reader = csv.DictReader(f)
        for row in reader:
            if name.lower() in row["Author"].lower():
                print(f"  → {row['Title']} (₹{row['Price']})")
                found = True
    if not found:
        print("  No books found!")

def add_book(bid, title, author, price, qty):
    """Append a new book"""
    with open(FILENAME, "a", newline='') as f:
        writer = csv.writer(f)
        writer.writerow([bid, title, author, price, qty])
    print(f"✅ '{title}' added to library!")

# Run all operations
create_library()
display_all()
search_by_author("Korth")
add_book(106, "Operating Systems", "Silberschatz", 710, 7)
display_all()

🆚 Binary File vs CSV File — Side-by-Side

📋 Board Exam Hotspot — Comparison Table

Feature	Binary File (`pickle`)	CSV File (`csv`)
Module	`pickle`	`csv`
Human-readable?	❌ No	✅ Yes
Stores Python objects?	✅ Any object	⚠️ Strings only
Opens in Excel?	❌ No	✅ Yes
File mode	`'rb'`, `'wb'`, `'ab'`	`'r'`, `'w'`, `'a'`
Write function	`pickle.dump()`	`writerow()` / `writerows()`
Read function	`pickle.load()`	`for row in reader:`
End of file detection	`EOFError` exception	Loop ends naturally
Type preservation	✅ int, list, dict intact	❌ Everything becomes string
Special parameter	None	`newline=''` in `open()`

Binary files and pickle

A binary file stores raw bytes; with pickle it can hold any Python object (list, dict, tuple …) with its type kept
import pickle → Pickling (serialization) = object → bytes: pickle.dump(obj, f)
Unpickling (deserialization) = bytes → object: obj = pickle.load(f)
Each load() returns one object, in the order they were dumped; past the last one it raises EOFError

Mode	Use	File missing	Existing data
`"wb"`	write a fresh file	creates it	erased
`"rb"`	read / search	`FileNotFoundError`	kept
`"ab"`	add records at the end	creates it	kept
`"rb+"`	read and write	`FileNotFoundError`	kept

The 4 binary-file programs

Write → open "wb", pickle.dump() each record
Read / display → open "rb", pickle.load() inside while True: + try, stop with except EOFError: break
Search → read every record, compare a field (rec["roll"] == r), use a found flag to print "not found"
Update → read all records into a list ("rb") → change the record in the list → write the whole list back ("wb")

CSV files (Comma-Separated Values)

Plain text, one row per line, values separated by commas; opens in Notepad and Excel
import csv and open with newline='' → without it, Windows gets a blank line after every row
Every value read back is a string → convert before maths: int(row[2])

Object	Method	Does
`w = csv.writer(f)`	`w.writerow(lst)`	writes one row
`w = csv.writer(f)`	`w.writerows(list_of_lists)`	writes many rows
`w = csv.DictWriter(f, fieldnames=cols)`	`w.writeheader()` then `w.writerow(dct)`	rows from dictionaries
`r = csv.reader(f)`	`for row in r:`	each row is a list of strings
`r = csv.DictReader(f)`	`for row in r:`	each row is a dict, keys from the first row

Skip the header row of csv.reader with next(r)

Text vs Binary vs CSV

	Text	Binary (`pickle`)	CSV (`csv`)
Human-readable	✅	❌	✅
Stores	strings	any Python object	rows of strings
End of data	`""` / loop ends	`EOFError`	loop ends
Typical file	`.txt`	`.dat`	`.csv`

Quick check: predict the output

import pickle
with open("nums.dat", "wb") as f:
    pickle.dump([1, 2], f)
    pickle.dump({"a": 3}, f)
count = 0
with open("nums.dat", "rb") as f:
    while True:
        try:
            obj = pickle.load(f)
            count += 1
        except EOFError:
            break
print(count, type(obj).__name__)

Output:

2 dict

Two objects were dumped, so there are exactly two load() calls before EOFError; the last object read is the dictionary.

🏆 Rapid Revision

💡 Study Strategy — 6 Must-Practise CBSE Questions

🖊️ "What is pickling? Write a program to write and read a dictionary using pickle"
🖊️ "Write a program to search a record in a binary file by a given field"
🖊️ "Write a program to update/modify a record in a binary file"
🖊️ "Difference between text file, binary file, and CSV file"
🖊️ "Write a program to write data into a CSV file using csv.writer"
🖊️ "Why is newline='' used when opening a CSV file in Python?"

⚠ Common Mistakes — Final Exam Checklist

❌ Forgetting import pickle or import csv
❌ Opening binary files in text mode ('w' instead of 'wb')
❌ Not handling EOFError in binary file reading loops
❌ Forgetting newline='' in CSV open() — causes blank rows
❌ Not converting CSV string values to int/float before arithmetic
❌ Trying to update a binary file record in-place (using 'rb+') instead of the read-all → modify → write-all pattern

# ✏️ Bonus Program: Export Binary File → CSV File
# The ultimate combo question — often seen in CBSE practicals!
import pickle, csv

# Step 1: Read all records from binary file
records = []
with open("students.dat", "rb") as bf:
    while True:
        try:
            records.append(pickle.load(bf))
        except EOFError:
            break

# Step 2: Write all records to CSV
with open("students.csv", "w", newline='') as cf:
    if records:
        writer = csv.DictWriter(cf, fieldnames=records[0].keys())
        writer.writeheader()
        writer.writerows(records)

print(f"✅ Exported {len(records)} records from binary (.dat) to CSV!")

🔐 File Handling in Python (Binary & CSV file)

🥒 Pickling, UnPickling & Structured Data Storage!

Binary File Basics

Pickling

UnPickling

Searching

Updating

CSV Files

🔒 5.5 Working with Binary Files

What Makes Binary Files Special?

🎁 The `pickle` Module

🗺️ Pickling & UnPickling — The Full Picture

🔑 5.5.1 Creating / Opening / Closing Binary Files

🥒 5.5.2 Writing onto a Binary File — Pickling!

📦 5.5.3 Reading from a Binary File — UnPickling!

🔍 5.5.4 Searching in a Binary File

✏️ 5.5.5 Updating in a Binary File

🧩 Complete Binary File Program — All Operations

📊 5.6 Working with CSV Files

What is a CSV File?

🔑 5.6.1 Opening / Closing CSV Files

✍️ 5.6.2 Writing in CSV Files

Method 1 — `csv.writer` (List-based)

Method 2 — `csv.DictWriter` (Dictionary-based)

📖 5.6.3 Reading in CSV Files

Method 1 — `csv.reader` (List-based)

Method 2 — `csv.DictReader` (Dictionary-based — Recommended!)

✍️ CSV Write Operation — Visual Guide

📖 CSV Read Operation — Visual Guide

🧩 Complete CSV Program — All Operations

🆚 Binary File vs CSV File — Side-by-Side

🏆 Rapid Revision

Recommended books optional

Sumita Arora — Progress in CS with Python

Oswaal Class 12 CS Question Bank

Need Help With This Chapter?

Save for Revision

Ask a Doubt

Report Issue / Feedback

Verified Doubts & Teacher Answers

🥒 Pickling, UnPickling & Structured Data Storage!

Binary File Basics

Pickling

UnPickling

Searching

Updating

CSV Files

🔒 5.5 Working with Binary Files

What Makes Binary Files Special?

🎁 The pickle Module

🗺️ Pickling & UnPickling — The Full Picture

🔑 5.5.1 Creating / Opening / Closing Binary Files

🥒 5.5.2 Writing onto a Binary File — Pickling!

📦 5.5.3 Reading from a Binary File — UnPickling!

🔍 5.5.4 Searching in a Binary File

✏️ 5.5.5 Updating in a Binary File

🧩 Complete Binary File Program — All Operations

📊 5.6 Working with CSV Files

What is a CSV File?

🔑 5.6.1 Opening / Closing CSV Files

✍️ 5.6.2 Writing in CSV Files

Method 1 — csv.writer (List-based)

Method 2 — csv.DictWriter (Dictionary-based)

📖 5.6.3 Reading in CSV Files

Method 1 — csv.reader (List-based)

Method 2 — csv.DictReader (Dictionary-based — Recommended!)

✍️ CSV Write Operation — Visual Guide

📖 CSV Read Operation — Visual Guide

🧩 Complete CSV Program — All Operations

🆚 Binary File vs CSV File — Side-by-Side

🏆 Rapid Revision

Recommended books optional

Need Help With This Chapter?

Save for Revision

Ask a Doubt

Report Issue / Feedback

Verified Doubts & Teacher Answers

Welcome

🎁 The `pickle` Module

Method 1 — `csv.writer` (List-based)

Method 2 — `csv.DictWriter` (Dictionary-based)

Method 1 — `csv.reader` (List-based)

Method 2 — `csv.DictReader` (Dictionary-based — Recommended!)