🔐 File Handling in Python (Binary & CSV file) Quiz

Pickling (also called Serialization) is the process of converting a Python object into a byte stream so it can be stored in a binary file.

Unpickling (also called Deserialization) is the reverse process — reading bytes from a binary file and reconstructing the original Python object.

pickle.dump(object, file_object) serializes the Python object and writes it to the binary file opened in 'wb' or 'ab' mode.

pickle.load(file_object) reads and reconstructs the next Python object from the binary file opened in 'rb' mode.

The correct syntax is pickle.dump(object, file_object) — the object to write comes first, then the file handle opened in binary write mode.

'wb' (write binary) opens a file for writing in binary mode. It creates the file if it doesn't exist, or overwrites all existing content if it does.

'rb' (read binary) opens an existing binary file for reading. It raises FileNotFoundError if the file does not exist.

'ab' (append binary) opens the file for writing at the end, preserving all existing records. It is the safe way to add new data to a binary file.

EOFError (End of File Error) is raised by pickle.load() when it tries to read past the last object in the file. This is how Python signals 'no more records'.

The standard CBSE pattern: while True: → try: record = pickle.load(f) → process → except EOFError: break. This reads records one by one until EOF.

In CBSE exam programs, binary pickle files conventionally use the .dat extension (e.g., students.dat). Python doesn't enforce this — it's a convention.

Binary files store data as raw bytes — not human-readable. Opening them in Notepad shows garbage characters. Python's pickle is needed to decode them.

The pickle module can serialize any Python object — integers, strings, lists, dictionaries, tuples, custom class instances — and perfectly restore them on loading.

Binary files preserve Python data types. A dict stored with pickle is loaded back as a dict with correct types. Text files convert everything to strings requiring manual conversion.

pickle.dump() stores the dict as bytes. pickle.load() perfectly reconstructs the original Python object — a dict. So type(data) is <class 'dict'>.

The CBSE-standard update pattern: (1) Read ALL records into a list using 'rb', (2) Modify target record in the list, (3) Rewrite ALL records using 'wb'. Direct in-place editing corrupts pickle files.

Each pickled object can have a different byte size. Overwriting one record may shift all byte positions after it, corrupting every subsequent record. Always use read-all → modify → write-all.

The first step is always to open the file in 'rb' mode and read ALL records into a Python list. Then filter out the target record from the list, and finally rewrite all remaining records using 'wb'.

Each pickle.dump() call writes one object. To write multiple records, loop through the list and dump each dictionary individually. This allows reading them back one at a time.

pickle.load() deserializes the bytes and returns the original Python object — with its exact type (dict, list, int, etc.) perfectly preserved.

CSV stands for Comma-Separated Values — a plain text format where each row is a line and each column is separated by a comma.

Python's built-in csv module handles CSV files. It requires import csv — no installation needed.

newline='' prevents Python from adding extra blank lines between data rows on Windows. It is essential when opening CSV files for writing: open('data.csv', 'w', newline='').

csv.writer(file_object) creates a writer that accepts lists or tuples and writes each one as a row in the CSV file.

csv.DictWriter(file_object, fieldnames=fields) creates a writer that accepts dictionaries. Keys automatically map to the correct column.

writer.writerow(list) writes a single list as one row in the CSV file. Each element in the list becomes one column value.

writer.writerows(list_of_lists) writes multiple rows in one efficient call. Each inner list becomes one row in the CSV file.

writer.writeheader() is exclusive to csv.DictWriter. It writes the fieldnames list as the first (header) row of the CSV file.

csv.reader(file_object) reads each row as a list of strings. Access columns by position: row[0], row[1], etc.

csv.DictReader(file_object) reads each row as a dictionary. The first row of the CSV is automatically used as keys. Access columns by name: row['Name'].

csv.reader returns all values as strings — even if the original was a number. You must manually convert: int(row[2]) or float(row[3]).

csv.reader returns all values as strings. So 95 (integer written) comes back as '95' (string). Output: ['Name', 'Marks'] then ['Aman', '95'].

The correct way is open('data.csv', 'w', newline=''). The newline='' parameter is required to prevent extra blank lines from being inserted between rows on Windows.

next(reader) reads and discards the first row (the header). Subsequent iterations in for row in reader: then start from the first data row.

csv.DictReader lets you access column values by their name (row['Marks']), making code cleaner and less error-prone than using index positions (row[2]).

Mode 'a' (append) with newline='': open('data.csv', 'a', newline=''). This places the write pointer at the end, preserving all existing rows.

import pickle, csv is the correct way to import both modules in one statement. Both are built-in — no installation required.

Binary/pickle files preserve Python data types (int stays int, dict stays dict). CSV files store everything as plain text strings — types must be converted manually when reading.

CSV files can be directly opened in Excel, Google Sheets, and any spreadsheet software. Binary/pickle files are not human-readable and cannot be opened in Excel.

In binary files, pickle.load() raises EOFError at EOF — you must catch it. In CSV files, for row in reader: ends naturally when all rows are read — no exception needed.

Two objects were dumped. Each pickle.load() reads one object. After two successful loads, the third raises EOFError → break. count = 2.

csv.DictWriter(file_object, fieldnames=['Name','Marks']) is correct. The fieldnames parameter specifies the column order and is required.

writeheader() writes the fieldnames list as the first row of the CSV — the column header row (e.g., Name,Roll,Marks,Grade).

Correct order: (1) Create DictWriter(f, fieldnames=...), (2) Call writeheader() to write the header row, (3) Call writerow(dict) for each data record.

Opening in 'wb' completely erases the existing content and writes the entire modified list fresh. Using 'ab' would add the modified records at the end while keeping the old (unmodified) ones, creating duplicates.

csv.reader returns all values as strings. So row[2] gives '95' (not 95). Output: '95' then '88' printed as strings without quotes (but they ARE strings internally).

CSV files are human-readable plain text and can be opened directly in Excel, Google Sheets, and imported into databases — making them ideal for data exchange.

csv.DictReader automatically reads the first row as column headers and uses them as dictionary keys for all subsequent data rows.

Without newline='', Python adds its own newline translation on Windows, causing an extra blank line between every data row in the CSV file, corrupting its structure.

The correct search pattern: open 'rb' → while True: → try: record = pickle.load(f) → check condition → except EOFError: break. There is no built-in search in pickle.

writerows() writes each inner list as a separate row: 1,A on line 1 and 2,B on line 2. It is equivalent to calling writerow([1,'A']) followed by writerow([2,'B']).

Binary files handled via Python's serialization mechanism require import pickle. The pickle module provides dump() and load() functions for reading and writing.

csv.DictReader returns each row as a dictionary. Column values are accessed by their header name as a key: row['Marks'].

pickle.dump([1,2,3], f) stores the list. pickle.load(f) retrieves it as a Python list. data[1] accesses index 1 → value is 2.

CSV values are always strings. To get an integer, you must explicitly convert: int(row['Marks']). Without this, arithmetic operations on CSV numbers will fail with TypeError.