NCERT Solutions Class 12 Computer Science Chapter 2 File Handling

A file is a named area on disk that stores data permanently. A text file stores data as readable characters and works with str objects. A binary file stores data as raw bytes, the same form held in memory, and works with bytes objects.

a) Text file vs binary file

b) readline() vs readlines()

• readline() reads one line at a time and returns it as a str. It returns an empty string "" at end of file and is light on memory.
• readlines() reads all the remaining lines in one call and returns a list of strings, one per line. It returns [] when nothing is left and loads the whole file into memory.

c) write() vs writelines()

• write() writes one string and returns the number of characters written.
• writelines() writes a list (or any iterable) of strings and returns None.
• Neither method adds a newline on its own, so you must put \n yourself.

Answer: Text files store readable characters with encoding and newline translation; binary files store raw bytes with neither. readline() returns one line as a string while readlines() returns every line as a list. write() takes one string while writelines() takes a list of strings, and neither adds a newline.

Each of these is a built-in tool for working with files. open() connects your program to a file and returns a file object. read() and seek() are methods of that file object. dump() belongs to the pickle module. "Use" means what the method is for; "syntax" means the exact way you call it.

• a) open() — Use: opens a file and returns a file object. If the mode is left out, the file opens in read text mode. Syntax: file_object = open(file_name, mode)
• b) read() — Use: reads characters from a text file (or bytes from a binary file). With no argument it reads the whole file; with a number n it reads at most n characters. Syntax: file_object.read(n) or file_object.read()
• c) seek() — Use: moves the file pointer to a chosen byte position so the next read or write happens there. seek(0) jumps back to the start. Syntax: file_object.seek(offset, from_where), where from_where is 0 for start (default), 1 for current, 2 for end.
• d) dump() — Use: from the pickle module, it writes (pickles) a whole Python object into a binary file in one step. Syntax: pickle.dump(object, file_object)

import pickle
f = open("data.txt", "r")     # open()
whole = f.read()              # read()
f.seek(0)                     # seek() back to start
f.close()

rec = {"id": 1, "name": "Asha"}
g = open("store.dat", "wb")   # binary write mode
pickle.dump(rec, g)           # dump()
g.close()

Answer: open(file, mode) returns a file object; f.read(n) reads characters; f.seek(offset, from_where) moves the pointer; pickle.dump(obj, f) saves a whole object to a binary file.

A file mode is the short string you pass to open() that decides what you can do. The base letters are r (read, pointer at start, file must exist), w (write, erases old content, makes the file if missing) and a (append, pointer at end, old content kept). A trailing + adds the opposite operation; a b turns the mode binary.

Note that "both read and write" without erasing means "r+", not "w+", because "w+" first empties the file.

Answer: (a) "r+", (b) "wb", (c) "a+", (d) "rb", opened exactly as in the table above.

When Python writes to a file it does not send each character straight to disk. It first stores the data in a small area of memory called a buffer. The buffer is copied to disk only when it fills up or when the file is closed; that copy is called flushing. The close() method flushes the buffer and then frees the file.

• Why we close: closing forces a final flush, so every byte you wrote is safely on disk. It also releases the file handle, a limited operating-system resource, and removes the lock so other programs can use the file.
• If we forget: the data still in the buffer may never reach the disk. On a clean exit Python usually flushes for you, but if the program crashes, the power fails, or the process is killed, the buffered data is lost and the file is left incomplete.
• Other side effects: open handles pile up. A long program that opens many files without closing them can run out of handles and fail to open more.
• Will an error be flashed? No. Forgetting to close a file does not raise an error by itself. The program keeps running with no warning; the damage shows up later as missing or partial data.

Answer: Close a file so the buffer is flushed to disk and the file handle is freed. If you do not close it, buffered data can be lost on a crash and handles can run out, but no error message is shown, the failure is silent.

Both snippets open the same file in read mode, but they differ in how much they read and in how the file is closed. The with statement creates a context manager: it opens the file, runs the indented block, then closes the file automatically when the block ends, even if an error occurs. read(n) reads at most n characters, while read() reads the whole file.

Answer: (a) reads only the first 10 characters, does not save them, and leaves the file open needing a manual close(). (b) reads the whole file into x and closes the file automatically when the block ends, even on error.

Append mode ("a") opens a file with the pointer at the end and keeps any old content, so new text is added below what is already there. The write() method writes one string and does not add a newline by itself, so we put \n at the end of each line to keep the three lines separate.

f = open("hello.txt", "a")
f.write(" Welcome my class\n")
f.write("It is a fun place\n")
f.write("You will learn and play\n")
f.close()

The same task using writelines() with a list:

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

If you drop the \n, all three lines run together as one long line, because write() never inserts a newline for you.

Answer: Open in "a" mode, then call f.write(...) for each line with a trailing \n (or use f.writelines(list)), and close the file.

Read mode ("r") opens an existing file with the pointer at the start so you can read it. To show the contents we read the whole file with read(). The key idea for the second part is that write mode ("w") is destructive, while append mode ("a") keeps the old content and adds to the end.

f = open("hello.txt", "r")
data = f.read()
print(data)
f.close()

If hello.txt holds exactly the three lines from question 6, the program prints:

 Welcome my class
It is a fun place
You will learn and play

Difference if write mode had been used in question 6:

• Opening in "w" would have erased everything already in hello.txt at the moment of opening.
• Only the three new lines would remain in the file.
• Append keeps the history of the file; write replaces it, so with write mode you lose any data that was there before.

Answer: The program opens hello.txt in "r" mode and prints its content with read(). Had question 6 used write mode "w", opening would have wiped any earlier content, leaving only the three new lines, whereas append mode preserved the old content and added to it.

We read input in a loop until a sentinel value, here the word "END", is typed; this is a sentinel loop. We write each sentence to a text file. To find sentences that start with a capital letter we re-open the file, read it line by line, and test the first character with isupper(), which returns True only for an uppercase letter.

f = open("sentences.txt", "w")
while True:
    line = input("Enter a sentence (END to stop): ")
    if line == "END":
        break
    f.write(line + "\n")
f.close()

f = open("sentences.txt", "r")
print("Sentences starting with an uppercase letter:")
for line in f:
    if line[0].isupper():
        print(line, end="")
f.close()

Sample run. If the user types Hello world, it was raining, Python is fun, the end is near, then END, the second loop prints:

Sentences starting with an uppercase letter:
Hello world
Python is fun

Note: line[0] fails with an IndexError on an empty line, so a stricter test is if line and line[0].isupper():.

Answer: Read sentences in a sentinel loop until "END", write each to a text file, then re-read line by line and print only the lines where line[0].isupper() is True.

A Python object such as a list or dictionary lives in memory and disappears when the program ends. The pickle module lets us keep it for later. Pickling (also called serialization) converts a Python object into a byte stream that can be written to a binary file. Unpickling (also called deserialization) is the reverse: it rebuilds the original object from that byte stream.

• Pickling / serialization: the object is changed into a stream of bytes with pickle.dump(object, file). The file must be opened in binary write mode "wb".
• Unpickling / deserialization: the byte stream is read back and turned into the same object with pickle.load(file). The file must be opened in binary read mode "rb".
• The recreated object has the same type and value as the original, so a saved dictionary comes back as the same dictionary.

import pickle

data = [10, 20, 30]
f = open("nums.dat", "wb")     # binary write
pickle.dump(data, f)           # serialize
f.close()

f = open("nums.dat", "rb")     # binary read
back = pickle.load(f)          # deserialize
print(back, type(back))
f.close()

[10, 20, 30] <class 'list'>

Answer: Pickling is converting a Python object into a byte stream so it can be stored in a binary file. Serialization is that conversion via pickle.dump(); deserialization is the reverse via pickle.load(), which rebuilds the exact original object.

We store several records in a binary file using pickle. Each record is a list [Item No, Item_Name, Qty, Price]. We collect all records in one master list and pickle that list with pickle.dump(). To display, we unpickle the list with pickle.load() and print each record, computing Amount as Price * Qty.

import pickle

n = int(input("How many records? "))
records = []
for i in range(n):
    item_no = int(input("Item No: "))
    name    = input("Item Name: ")
    qty     = int(input("Qty: "))
    price   = float(input("Price: "))
    records.append([item_no, name, qty, price])

f = open("items.dat", "wb")
pickle.dump(records, f)
f.close()

import pickle

f = open("items.dat", "rb")
records = pickle.load(f)
f.close()

for r in records:
    item_no, name, qty, price = r
    amount = price * qty
    print("Item No:", item_no)
    print("Item Name:", name)
    print("Quantity:", qty)
    print("Price per item:", price)
    print("Amount:", amount)
    print("-" * 25)

Sample run. For two records [1, "Pen", 10, 5.0] and [2, "Notebook", 3, 40.0], the display loop prints:

Item No: 1
Item Name: Pen
Quantity: 10
Price per item: 5.0
Amount: 50.0
-------------------------
Item No: 2
Item Name: Notebook
Quantity: 3
Price per item: 40.0
Amount: 120.0
-------------------------

Answer: Read n records of [Item No, Name, Qty, Price], pickle.dump() the list to a "wb" file, then pickle.load() from a "rb" file and print each record with Amount = Price * Qty.