NCERT Notes Class 12 Computer Science Chapter 2 File Handling

Inside the Notes for Class 12 Computer Science Chapter 2 File Handling in Python, you will find every file access mode, the read and write methods, the seek() and tell() offset rules, and how the pickle module saves a whole Python object to a binary file. These revision notes follow the latest 2026-27 CBSE syllabus and compress the NCERT chapter into fast, exam-ready blocks.

• Every method explained with its one-line use, syntax, and a short Python code block you can trace by hand.
• Full coverage of text vs binary files, the r/w/a modes, write()/read()/readlines(), seek()/tell() and pickle dump/load that the CBSE board paper tests.
• Notes aligned with the 2026-27 CBSE Class 12 Computer Science syllabus and useful for JEE and CUET programming questions; no NEET references because Computer Science is not a medical subject.

These Collegedunia revision notes are curated by Computer Science subject experts, according to the 2026-27 NCERT textbook, and refined against the last five years of CBSE Class 12 Computer Science board papers.

What the Notes for Class 12 Computer Science Chapter 2 File Handling in Python Cover

This chapter answers one question: how does a Python program keep its data after it stops running? These notes follow the NCERT order but compress it into revision-ready blocks, so you can read the whole chapter in one sitting and recall it fast in the exam.

• Text file vs binary file: human-readable characters versus raw bytes that stand for images, audio, or saved Python objects.
• Opening and closing: open() returns a file object, and close() flushes the buffer and saves the data to disk.
• Access modes: r for read, w for write, a for append, + for both, and b for binary.
• Read, write and offsets: write(), writelines(), read(), readline(), readlines(), plus seek() and tell() for moving inside the file.
• Pickle module: dump() and load() serialise and deserialise a whole Python object to and from a binary file.

Files: Why Programs Need Permanent Storage in Class 12 Computer Science

Every program you have written so far reads input, works on it, and prints the answer. The trouble is that the data vanishes the moment the program ends, because variables live only in memory. To keep data for later, you save it on disk in a file. Getting this vocabulary right is what the first question on the chapter rewards.

A file is a named location on a secondary storage device, such as a hard disk or a pen drive, where data are stored permanently. This is exactly why schools store student records, shops store stock lists, and games store your saved progress in files rather than in memory. To use the saved data again, another program reads the file back into RAM, so saving and loading is a two-way movement between memory and disk.

Text File vs Binary File in Python

At the lowest level every file is just a series of bytes, that is, 0s and 1s. Based on how those bytes are meant to be read, Python deals with two kinds of data files. Naming the right type and giving a valid extension is a frequent 1-mark or 2-mark board question.

A text file looks like neat lines of text, but it is really stored as a sequence of bytes. Each character is saved as its numeric code in a scheme such as ASCII or Unicode. For example, the letter A is stored as the value 65. Each line ends with a special End of Line (EOL) character, which in Python is the newline written as \n. A binary file, by contrast, has no line concept and would look like junk if you opened it in a text editor.

Opening and Closing a File with open() and close() in Python

Before you can read from or write to a file, you must open it. Opening links your program to the file on disk and tells Python what you plan to do: read, write, or append. When the work is over, you close the file to save the data safely and free the resources.

The open() function and the file object

To open a file you call open(). It needs the file name and, optionally, an access mode. It returns a file object, also called a file handle, which you store in a variable and use for every later operation on that file.

file_object = open(file_name, access_mode)

f = open("marks.txt", "r")
print(f.name)     # marks.txt
print(f.mode)     # r
print(f.closed)   # False

If the file does not exist, opening in a write or append mode creates a new empty file with that name. If the file is not in the current folder, you must give the full path. The file object also carries handy attributes: f.name returns the name, f.mode returns the mode, and f.closed returns True only after the file is closed.

Closing a file with close() and the with clause

Once you finish, close the file with close(). Closing flushes the buffer, that is, it pushes any unsaved data from memory to the disk, and frees the memory the file used. Python offers a neater way too: the with clause, which closes the file for you automatically even if an error happens inside the block.

f = open("data.txt", "w")
f.write("Saved safely")
f.close()                       # buffer flushed, file saved

with open("data.txt", "r") as f:
    text = f.read()             # auto-closed at the end of the with block

File Access Modes Every Class 12 Student Must Know

The access mode decides what you may do with the file and where the file object starts reading or writing. This starting spot is called the offset. The basic letters are r for read, w for write, a for append, and + for both reading and writing. Adding b opens the file in binary mode; without it the file is in text mode, the default. If you give no mode at all, Python uses read mode.

The offset is why write mode can erase data while append mode never does. Modes r, w and r+ place the offset at the start of the file, while a and a+ place it at the end. This single fact explains the most common board question on the difference between write and append mode.

Writing to a Text File: write() and writelines() in Python

Two methods send data into a text file. The write() method takes one string and writes it as is. The writelines() method takes a list of strings and writes them one after another. Neither method adds a newline on its own, so you must add \n yourself when you want separate lines.

• write(string): writes a single string to the file and returns the number of characters written.
• writelines(list): writes every string in a list or tuple, with no newline added between them.
• Buffer: written data waits in a buffer and is pushed to disk only on close() or when the buffer fills.

f = open("hello.txt", "a")          # append mode keeps old data
f.write("Welcome my class\n")
lines = ["It is a fun place\n", "You will learn and play\n"]
f.writelines(lines)
f.close()

Because the file above is opened in append mode, the three lines are added at the end and the earlier contents stay safe. Open the same file in w mode instead and the old contents would be wiped before the new lines are written. This contrast between a and w is the heart of most write-related board questions.

Reading from a Text File: read(), readline() and readlines()

Three methods read text back from a file, and the exam loves to ask the difference between them. Pick the method by how much you want at a time: the whole file, one line, or a list of all lines.

The single letter s in readlines() is the whole difference: readline() returns one line as a string, while readlines() returns a list of every line. A clean way to traverse a file is a for loop over the file object, which reads it line by line without loading it all at once.

with open("hello.txt", "r") as f:
    for line in f:                  # reads one line per pass
        print(line, end="")         # \n is already in the line

Setting Offsets with seek() and tell() in Class 12 Computer Science

Every open file keeps a file offset, the position of the next byte to be read or written. Two methods work with it. The tell() method reports the current offset, and the seek() method moves the offset to a new spot. Together they let you jump around inside a file instead of always reading from the start.

• tell(): returns the current position of the offset as a number of bytes from the start of the file.
• seek(offset, from): moves the offset; from is 0 for the start, 1 for the current spot, and 2 for the end.
• Default: seek(0) rewinds to the very beginning, which is handy before re-reading a file.

with open("hello.txt", "r") as f:
    print(f.tell())     # 0  (offset at the start)
    print(f.read(5))    # reads 5 characters
    print(f.tell())     # 5  (offset moved forward)
    f.seek(0)           # rewind to the beginning
    print(f.tell())     # 0  (back at the start)

After reading five characters the offset is at position 5, which tell() reports. Calling seek(0) then rewinds it to 0, so the next read starts fresh. In text mode the second argument of seek() is usually 0, because moving relative to the current spot or the end is reliable only in binary mode.

The Pickle Module and Binary Files in Python

A text file stores only characters, so a list or a dictionary would lose its structure if you wrote it as text. The pickle module solves this by saving a whole Python object to a binary file and reading it back exactly as it was. You must import pickle and open the file in a binary mode.

Serialization and deserialization

Pickling means turning a Python object into a byte stream so it can be stored in a binary file. Serialization is this conversion of an object into a stream of bytes, and deserialization (unpickling) is the reverse, rebuilding the object from those bytes. The two methods that do the work are dump() and load().

import pickle

record = {"ItemNo": 1, "Name": "Pen", "Qty": 50, "Price": 8.5}
with open("stock.dat", "wb") as f:    # wb = write binary
    pickle.dump(record, f)            # object saved to disk

with open("stock.dat", "rb") as f:    # rb = read binary
    data = pickle.load(f)             # object rebuilt
print(data["Name"])                   # Pen

To read many records back, call load() in a loop. When there are no more records, load() raises an EOFError, so a try-except around the loop is the clean way to stop at the end of the file. This EOFError trap is the most common 3-mark binary-file question, so practise it from the PDF.

One-Glance Revision Strip and Common Exam Traps

This is the strip to read in the last five minutes before the exam. It lines up every method with its one-line role, then lists the traps that cost students marks every year in the File Handling chapter.

Previous Year Question Trends from the File Handling Chapter

The File Handling chapter is tested in CBSE board papers through differences between methods, output-tracing, and a full program on text or binary files. The table below maps the asked question types across recent board papers, so your revision can target the high-frequency areas.

Also Check: The full set of CBSE board paper questions for this chapter, with step-by-step answers, is included in the downloadable PDF above, updated for the 2026-27 cycle.

Other Resources for Class 12 Computer Science Chapter 2 File Handling in Python

Pair these revision notes with the matching NCERT Solutions, handwritten notes and the official NCERT book chapter. All resources for Class 12 Computer Science Chapter 2 File Handling in Python are linked below.

Notes for Class 12 Computer Science: All Chapters

Related Links: Use the table below to open the revision notes for the other chapters of Class 12 Computer Science. Every chapter ships with the same concept-first notes style, full PDF download, and revision FAQ.