Q.Find the output of the following C++ code considering that the binary file STOCK.DAT exists on the hard disk with the following 5 records for the class STOCK containing Name and Price. Name Price Rice 110 Wheat 60 Cheese 200 Pulses 170 Sauce 150 void main() { fstream File; File.open("STOCK.DAT",ios::binary|ios::in); Stock S; for (int I=1; I<=2; I++) { File.seekg((2*I-1)sizeof(S)); File.read((char)&S, sizeof(S)); cout << "Read : " << File.tellg()/sizeof(S)<< endl; } File.close(); }

When you work with files in Python, the mode string you pass to the open() function determines exactly what you can do with that file — read, write, append, or a combination. The question asks specifically for read-only mode, which means the file should be opened only for reading, not for writing or appending.

Let's look at each option:

• (A) "a" — This stands for append mode. It opens the file for writing, but data is added at the end of the file. It is not read-only at all. In fact, if the file does not exist, "a" creates a new one. So this is incorrect.

• (B) "rb" — The "r" means read, and the "b" means binary mode. Together, "rb" opens the file for reading in binary format. This is indeed a read-only mode — you cannot write to the file. Among the given options, this is the correct one.

• (C) "r+" — The "+" adds both reading and writing. So "r+" opens the file for both reading and writing. It is not read-only; you can modify the file. Hence, it is incorrect for the given requirement.

• (D) "rb+" — This combines binary mode with read-write access. Like "r+", it allows both reading and writing, just in binary format. So it is also not read-only. …

In Python, interacting with files is a fundamental aspect of many programs, allowing us to store and retrieve data persistently. The statement F = open('CONTENT.TXT') is the first step in this process. It opens a file named CONTENT.TXT in the default read mode ('r') and returns a file object, which we've assigned to the variable F. This file object acts as a gateway, providing methods to perform operations like reading, writing, and, importantly, navigating within the file.

One crucial method for navigating within a file is seek(). Imagine a cursor in a text editor; seek() allows you to move this cursor to a specific location within the file. This is incredibly useful when you need to re-read a part of a file, skip certain sections, or write data at a precise point.

The seek() method takes two arguments: seek(offset, whence).

• The offset argument specifies the number of bytes to move. This can be a positive or negative integer, depending on the whence argument.
• The whence argument determines the reference point from which the offset is calculated. This is where the strict rules apply, and understanding these values is key to using seek() correctly.

There are only three valid integer values for whence:

• 0 (or os.SEEK_SET): This means the offset is relative to the beginning of the file. When whence is 0, the offset must be a non-negative integer, as you cannot move before the start of the file.
• 1 (or os.SEEK_CUR): This means the offset is relative to the current file position. The offset can be positive (to move forward) or negative (to move backward) from the current position.
• 2 (or os.SEEK_END): This means the offset is relative to the end of the file. When whence is 2, the offset is typically a non-positive integer (0 or negative) to move backward from the end of the file. A positive offset from the end would move beyond the file's actual content.

Now, let's examine the given statements based on these rules: …

When working with files in programming, the mode you choose determines not just whether you can read or write, but also where the file pointer starts and how the existing content is treated. Understanding these distinctions is essential for handling data correctly.

The r mode opens a file for reading only. The file pointer sits at the beginning, ready to read from the start. You cannot write in this mode, and if the file doesn't exist, you'll get an error. It's purely for consumption of existing data.

The r+ mode opens a file for both reading and writing. The file pointer again starts at the beginning. This means if you write immediately, you'll overwrite existing content from the start unless you explicitly move the pointer. The file must already exist, or the operation fails. It's a two-way mode but begins at the top.

The w mode opens a file for writing. Here's the crucial behavior: it truncates the file, meaning any existing content is wiped out the moment you open it. The file pointer is at the beginning of what is now an empty (or newly created) file. If the file didn't exist, it gets created. This mode is destructive by design. …

When you work with files, the operating system tracks your current position within the file — the "file pointer". The seek() method lets you move this pointer manually. Its syntax is file_object.seek(offset[, reference_point]), where offset is the number of bytes to move and reference_point is the position the offset is measured from.

There are three standard reference points:

Because moving to an absolute position from the start of a file is by far the most common need, seek() makes 0 the default. So f.seek(7) is exactly the same as f.seek(7, 0) — both move the pointer 7 bytes from the beginning. …

When working with files in Python, we often need to specify how we intend to interact with the file. This is done through what are called "modes" when opening a file. These modes dictate whether you want to read from the file, write to it, append new content, or a combination of these actions, and also define how the system should behave if the file doesn't exist or already contains data. Understanding these modes is fundamental to effective file handling.

Let's look at the common file modes:

• 'r' (Read Mode):

  This is the default mode. When you open a file in read mode, you can only read its contents. You cannot modify or add new data.

  Watch out

  If the file you are trying to open in 'r' mode does not exist, Python will raise a FileNotFoundError. It will never create a new file in this mode.

• 'r+' (Read and Write Mode):

  This mode allows you to both read from and write to a file. The file pointer is initially at the beginning of the file.

  Important

  Similar to 'r' mode, if the file does not exist when opened in 'r+' mode, Python will raise a FileNotFoundError. It does not create a new file. If the file exists, writing will occur from the current position of the file pointer, potentially overwriting existing content from that point onwards.

• 'w' (Write Mode):

  This mode is specifically for writing data to a file. It has a very distinct behavior regarding file existence:

  • If the file does not exist, Python will create a new, empty file with the specified name. …

When you work with files in Python, you are essentially moving a cursor through a stream of data. Every time you read or write, that cursor advances. The tell() method is the tool that tells you exactly where that cursor is at any moment — it returns the current position (as an integer representing bytes from the beginning of the file).

The syntax follows the standard object-oriented pattern in Python. A file object — created by open() — has methods attached to it. You access those methods by writing the object's name, a dot, and then the method name. So file_object.tell() is the correct form. No argument is needed inside the parentheses because tell() simply reports the current position; it does not change it.

Now look at the options given:

• (a) tell.file_object() — This is wrong because it treats tell as if it were the object and file_object as a method. In Python, the object comes first, then the dot, then the method.
• (b) file_object.tell() — This is correct. The file object is the thing that knows its position, and tell() is the method that asks it. …

When working with text files in Python, a common task is to read their contents. Python provides several methods for this, each suited for different scenarios. Understanding the nuances of these methods, particularly readlines() and readline(), is crucial for efficient and correct file handling. These methods allow us to access the data stored in a file, whether we need it all at once or line by line.

The readlines() method is designed for situations where you need to load the entire content of a text file into memory as a collection of individual lines. When you call readlines() on an open file object, it performs the following actions:

• It reads every single line from the current position in the file until the end of the file is reached.
• It collects these lines into a list.
• Each element in this list is a string, representing one line from the file.
• Crucially, each of these string elements retains the newline character (\n) at its end, which marks the termination of a line in the text file.

In contrast, the readline() method operates differently. Its purpose is to read a file one line at a time, which is particularly useful when dealing with very large files that might not fit entirely into memory, or when you need to process each line individually before moving to the next.

• When readline() is called, it reads only the next single line from the file.
• It returns this line as a single string.
• Similar to readlines(), this string also includes the newline character (\n) at its end, if present in the file.
• If readline() is called again, it reads the subsequent line. This sequential reading continues until the end of the file. When the end of the file is reached, subsequent calls to readline() will return an empty string ('').

Now, let's evaluate the given Assertion and Reasoning: …

Part (a)

To write new content into a text file you use write mode, "w". If the file does not exist Python creates it; if it does exist, its contents are truncated (erased) before writing begins.

f = open("WRITEUP.TXT", "w")
``` …