File Handling in Python – Class 12 Important MCQs with Answers & Explanations

Explanation:

A file in Python (or any operating system) is a named storage location on a secondary storage device such as a hard disk, SSD, or flash drive.
It allows permanent storage of data, which means that the data remains even after the program execution ends — unlike variables stored in RAM, which are erased when the program stops.

Python provides built-in support for file handling through functions like open(), read(), write(), and close(). These enable reading from and writing to files in both text and binary formats.

Explanation:

Variables in Python are stored in the main memory (RAM), which is volatile in nature.
This means that once a Python program finishes execution or the system shuts down, all the data stored in variables is automatically erased.

Hence, if you want your data to remain available after the program ends, you must store it in a file (text or binary) or a database.
This is the main reason file handling is introduced — to achieve data persistence (permanent storage).

For example:

name = "Mohan"
print(name)
# After program ends, 'name' is deleted from memory

To make it permanent:

f = open("data.txt", "w")
f.write("Mohan")
f.close()

Now, “Mohan” is stored permanently in the file data.txt.

Explanation:

Files in Python (or any programming language) are used to store data permanently on a secondary storage device (like HDD or SSD).

Key Points:

1. Data Persistence: Unlike variables stored in RAM (which are temporary), data in files remains after program execution ends.
2. Reusability: Once stored, data in files can be read and used multiple times by the same or different programs.
3. Avoids Repetitive Input: Users don’t need to re-enter the same data every time the program runs.

Files can store both text and binary data, so they are not limited to only text.

Example in Python:

# Writing data to file
f = open("student.txt", "w")
f.write("Name: Mohan\nAge: 18")
f.close()

# Reading data later
f = open("student.txt", "r")
print(f.read())
f.close()

Here, data is persistent and can be reused anytime by reading the file.

Explanation:

Python programs written in script mode are saved as source code files.

• The .py extension indicates that the file contains Python code.
• When you run a .py file, the Python interpreter reads the file and executes the code.
• Other file extensions like .txt or .csv are not executable Python scripts; they are treated as data files.

Example:

# Save this as hello.py
print("Hello, World!")

Running this script using:

python hello.py

will execute the code and print:

Hello, World!

Explanation:

• Internally, all files on a computer—whether text, images, audio, or video—are stored as a sequence of bytes (each byte is 8 bits).
• The computer interprets these bytes differently depending on the file type:
  • Text files: Bytes are interpreted as characters using an encoding standard (e.g., ASCII, UTF-8).
  • Binary files: Bytes may represent images, audio, executable instructions, etc.
• This uniform representation allows the computer to handle any type of file consistently at the hardware level.

Example:

• Text file "hello.txt": stored as bytes corresponding to ASCII codes for h, e, l, l, o.
• Image file "photo.jpg": stored as binary bytes that the image viewer interprets according to JPEG format.

Explanation:

Python primarily works with two types of data files:

1. Text Files:
   • Contain human-readable characters.
   • Examples: .txt, .py, .csv.
   • Can be read and edited with a text editor.
   • Python reads/writes text files using default encoding (like UTF-8).
   f = open("example.txt", "w") f.write("Hello, World!") f.close()
2. Binary Files:
   • Contain non-human-readable bytes.
   • Examples: .dat, .bin, .jpg, .mp3.
   • Used for images, audio, executable files, or any non-text data.
   • Python reads/writes binary files using "rb" (read binary) or "wb" (write binary) modes.
   f = open("example.bin", "wb") f.write(b"\x00\x01\x02") f.close()

Summary: Text files are readable and editable; binary files are for efficient storage and machine-readable data.

Explanation:

Text files are files that contain data stored as human-readable characters, usually encoded in ASCII or Unicode (UTF-8) format.

Key points:

• Text files can be opened and edited using any text editor such as Notepad, VS Code, Sublime Text, or IDLE.
• They store data in plain text — for example, words, numbers, or symbols.
• Python programs often use text files (.txt, .py, .csv) for storing readable information.
• When opened, the text is directly visible and understandable to humans.

Example in Python:

f = open("notes.txt", "w")
f.write("Python is fun!")
f.close()

# This file can be opened in Notepad and will show: Python is fun!

Text files differ from binary files, which contain data in byte form (not directly readable).

Explanation:

Text files are those that contain human-readable characters and can be opened using simple text editors such as Notepad, VS Code, or IDLE.

Common text file extensions include:

• .txt → Plain text file (simple readable text)
• .py → Python source code file (also text-based)
• .csv → Comma Separated Values file (data in table form)
• .html → Webpage source file (HTML code, readable text format)

On the other hand:

• .exe, .dll are binary/executable files.
• .jpg, .png are image (binary) files.
• .bin, .dat are pure binary data files.

Example:

f = open("example.txt", "w")
f.write("This is a text file.")
f.close()

The file example.txt can be opened in any text editor and read easily.

Explanation:

Binary files store data in the form of bytes (0s and 1s) — not in human-readable characters.
This means that when you open a binary file in a text editor like Notepad, you’ll see unreadable symbols or gibberish, because the data is encoded for machines, not for human interpretation.

Key Differences:

Aspect	Text File	Binary File
Readability	Human-readable	Machine-readable
Storage format	Characters (ASCII/Unicode)	Bytes (0s and 1s)
Examples	.txt, .py, .csv	.dat, .bin, .jpg, .exe
Opening	Can be opened by text editor	Needs special program (e.g., image viewer, audio player)

Example in Python:

# Writing binary data
f = open("data.bin", "wb")
f.write(b'\x42\x79\x74\x65\x73')  # Writing bytes
f.close()

Opening data.bin in a text editor will show symbols like “Bytës” or gibberish, not readable text.

Explanation:

When a text file is opened in Python (using open()), the data in the file is read or written as text, but internally, Python stores and processes this data as Unicode characters represented in bytes form.

Here’s what happens step-by-step:

1. Each character in the text file (like 'A', 'b', '3', etc.) is represented by a Unicode code point.
2. These code points are then encoded into bytes (using encodings such as UTF-8 or ASCII) before being stored on disk.
3. When reading the file, Python decodes the bytes back into characters, making it human-readable again.

Example:

# Writing to a text file
f = open("demo.txt", "w", encoding="utf-8")
f.write("Hello")
f.close()

# Internally, 'Hello' is stored as bytes: 72 101 108 108 111

So even though the file appears to contain text, the computer actually stores it as a sequence of bytes (0s and 1s) corresponding to Unicode values.

Explanation:

Every file in a computer system — whether it’s a text file, image, audio, or video — is stored internally as binary data, i.e., a sequence of bytes (0s and 1s).
These bytes are interpreted differently depending on the file type and encoding scheme. For example:

• Text files use encodings like ASCII or UTF-8,
• Image or audio files use binary formats specific to their type.

Explanation:

• Text files store data as a sequence of characters using encodings such as ASCII or UTF-8.
  → They can be opened easily in text editors like Notepad or VS Code.
• Binary files, on the other hand, store data in machine-readable (0s and 1s) form.
  → They can only be interpreted correctly by the specific program that created them (e.g., images, audio, videos, etc.).

Examples:

• Text file: .txt, .py, .csv
• Binary file: .exe, .jpg, .dat

“Text files contain data in character form which can be read easily, while binary files contain data in machine-readable form.”

Explanation:

Text files in Python store data in human-readable character format (ASCII or Unicode).
Common text file extensions include:

• .txt → Plain text file
• .py → Python source code file
• .csv → Comma-Separated Values file (text-based data storage)

These files can be opened easily in text editors like Notepad, VS Code, or even Excel (for .csv).

“Examples of text files include .txt, .py, and .csv files that contain data in readable character form.”

Explanation:

When a text file is opened in an editor (like Notepad or VS Code), the file’s contents — which are stored as byte values representing characters — are decoded using a specific character encoding scheme (such as ASCII or UTF-8).
This decoding process converts numeric byte values into human-readable characters (letters, digits, symbols, etc.).

For example:

• The ASCII code 65 corresponds to the character ‘A’.
• The ASCII code 97 corresponds to ‘a’.

Thus, what you see as readable text is actually the decoded representation of stored byte data.

“A text file stores data as a sequence of characters that represent their ASCII or Unicode values, which text editors can directly interpret and display.”

Explanation:

• ASCII (American Standard Code for Information Interchange) assigns unique numeric codes to characters.
• In ASCII:
  • 65 → 'A' (capital A)
  • 97 → 'a' (small a)
  • 48–57 → digits '0' to '9'

Each ASCII value can also be represented in binary. For example:

65 in decimal = 1000001 in binary

Python example:

print(ord('A'))  # Output: 65
print(chr(65))   # Output: 'A'

Here, ord() returns the ASCII/Unicode code of a character, and chr() converts a number to its corresponding character.

Explanation:

• The End of Line (EOL) character in a text file is used to signal the end of the current line and move the cursor to the beginning of the next line.
• Different operating systems use different EOL characters:
  • Windows: \r\n (Carriage Return + Line Feed)
  • Unix/Linux/MacOS: \n (Line Feed)
• In Python, when reading or writing files, EOL characters help separate lines for proper display or processing.

Example in Python:

f = open("example.txt", "w")
f.write("Hello\nWorld")
f.close()

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

Output:

Hello
World

Here, \n is the EOL character that moves the text to a new line.

Explanation:

• In Python, the default End of Line (EOL) character for text files is the newline character \n.
• When writing or reading text files, Python interprets \n as a signal to move to the next line.
• Python automatically translates the newline character based on the operating system when opening files in text mode ('r' or 'w'):
  • Windows: Converts \n to \r\n in the file
  • Unix/Linux/MacOS: Keeps \n as is

Example in Python:

f = open("example.txt", "w")
f.write("Line 1\nLine 2\nLine 3")
f.close()

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

Output:

Line 1
Line 2
Line 3

Here, each \n ensures the text moves to a new line.

Explanation:

• In text files, especially structured data files like CSV (Comma Separated Values) or TSV (Tab Separated Values), commas and tabs are commonly used as delimiters to separate individual values.
• This allows programs to parse and process the data correctly.
• Example:

CSV example:

Name,Age,City
Mohan,18,Delhi
Puja,15,Mumbai

TSV example:

Name\tAge\tCity
Mohan\t18\tDelhi
Puja\t15\tMumbai

• In Python, the csv module can handle both comma and tab separators.

import csv

with open("data.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

Explanation:

• Text files (.txt) store plain text in ASCII or Unicode. They do not include formatting (fonts, styles, colors) or metadata.
• .docx files (Microsoft Word documents) are complex files that contain:
  • Text content
  • Formatting (bold, italics, font sizes)
  • Page layout, images, tables
  • Metadata (author, creation date, revision history)
• Hence, .docx files are not directly readable in simple text editors like Notepad without losing formatting.

Example:
Opening example.txt in Notepad:

Hello World

Opening example.docx in Notepad:

PK�� ... (binary symbols representing formatting and XML content)

Explanation:

• A .txt file stores only plain text, so it has minimal size — usually 1 byte per character.
• A .docx file stores:
  • Text content
  • Formatting (bold, italics, fonts)
  • Metadata (author, revision history)
  • Page layout information
• Due to this extra data, a .docx file is significantly larger than a .txt file containing the exact same text.

Example:

• example.txt containing “Hello World” → ~11 bytes
• example.docx containing “Hello World” → ~10–15 KB (depends on Word version and metadata)

Explanation:

• Binary files store data in raw byte format, not as human-readable characters.
• Examples include:
  • Images: .jpg, .png
  • Audio/Video: .mp3, .mp4
  • Executables: .exe, .bin
• Unlike text files, binary files cannot be correctly read in a simple text editor because they include non-ASCII byte sequences representing the actual content.

Python Example:

# Writing binary data
with open("example.bin", "wb") as f:
    f.write(b'\x89PNG\r\n\x1a\n')  # First bytes of a PNG image

Opening example.bin in Notepad shows garbled symbols, not readable text.

Explanation:

• Text editors are designed to interpret bytes as ASCII/Unicode characters.
• Binary files contain machine-readable data (images, audio, videos, executables) that do not follow ASCII encoding.
• When a binary file is opened in a text editor, the editor tries to map bytes to characters, producing unreadable symbols or “garbage characters”.

Example:
Opening a PNG image in Notepad might display:

‰PNG
��� IHDR���

This is not meaningful text, it’s the raw byte data of the file.

Explanation:

• Binary files store data in a precise sequence of bytes.
• Each bit represents part of the actual data (image pixels, audio samples, executable instructions, etc.).
• Even a single-bit change can alter the structure, making the file unreadable or corrupted by the program that uses it.
• Example:
  • Flipping one bit in a PNG image may make it fail to open in an image viewer.
  • Changing a byte in an executable could make it fail to run.

This is why binary files are more sensitive to corruption than text files.

Explanation:

• Binary files store data as raw bytes representing images, audio, videos, or executable instructions.
• Unlike text files, this data is not human-readable, meaning we cannot easily see the content or understand its structure.
• Therefore, manual correction of errors in binary files is extremely difficult. Specialized software tools (like hex editors) are required to modify or repair binary data.

Example:
Opening a .png or .exe file in Notepad shows garbled symbols, making it impossible to fix an error just by reading the content.

Explanation:

• Python uses the io module to handle all file input/output operations.
• The module provides classes and methods for both text and binary files:
  • Text files: io.TextIOWrapper
  • Binary files: io.BufferedReader, io.BufferedWriter
  • In-memory streams: io.StringIO, io.BytesIO
• Even though the built-in open() function is commonly used, it internally relies on the io module.

Example:

import io

# Writing to a text file
with io.open("example.txt", "w", encoding="utf-8") as f:
    f.write("Hello Puja\n")

# Reading from a text file
with io.open("example.txt", "r", encoding="utf-8") as f:
    print(f.read())

Explanation:

• The open() function in Python is used to open a file and create a file object that acts as a link between the program and the actual file stored on secondary storage (HDD, SSD).
• Once a file is opened, we can perform read, write, or append operations using the file object.
• Syntax:

file_object = open("filename.txt", "mode")

Common modes:

• 'r' → read
• 'w' → write (overwrites existing content)
• 'a' → append
• 'rb' / 'wb' → binary read/write

Example:

# Open a file in write mode
f = open("example.txt", "w")
f.write("Hello Puja\n")
f.close()

Here, open() establishes the connection between Python and the file for operations.

Explanation:

• The correct syntax of the open() function in Python is:

file_object = open(filename, access_mode)

• Parameters:
  • filename → Name of the file (string)
  • access_mode → Mode in which the file is opened ('r', 'w', 'a', 'rb', 'wb', etc.)
• The function returns a file object (handle), which can be used to read from or write to the file.

Example:

# Open a file in read mode
f = open("example.txt", "r")
content = f.read()
f.close()
print(content)

Here, f is the file object returned by open().

• Other options are incorrect:
  • open.file() → invalid syntax
  • open(filename, mode, variable) → no third argument called variable

Explanation:

• When a file is successfully opened using open(), Python returns a file object, also called a file handle.
• This object acts as an interface to perform operations like reading, writing, or appending data to the file.
• Example:

# Opening a file in write mode
f = open("example.txt", "w")  # f is the file object
f.write("Hello Puja\n")
f.close()

• The file object provides methods like:
  • .read(), .readline(), .readlines() → reading data
  • .write(), .writelines() → writing data
  • .close() → closing the file
• Other options are incorrect:
  • Boolean → only returned if an error check is performed
  • String containing file path → no, file object is returned
  • Number of bytes → not returned by open()

Explanation:

• Behavior depends on the mode specified:
  1. 'r' → Raises FileNotFoundError if the file does not exist.
  2. 'w' → Creates a new empty file if it does not exist.
  3. 'a' → Creates a new empty file if it does not exist, then appends data.
  4. 'x' → Creates a new file, but raises an error if it already exists.

Example in Python:

# Writing mode creates a new file if it doesn't exist
f = open("newfile.txt", "w")  
f.write("Hello Mohan\n")
f.close()

# Reading mode raises error if file doesn't exist
f = open("nofile.txt", "r")  # FileNotFoundError

• Key Point: Python does not always create a file automatically. Automatic creation happens only in write (w), append (a), or exclusive-create (x) modes.

Explanation:

• In Python, every file object has a closed attribute.
• This attribute indicates whether the file is currently closed:
  • True → file is closed
  • False → file is still open

Example:

f = open("example.txt", "w")
print(f.closed)  # Output: False

f.write("Hello Mohan\n")
f.close()

print(f.closed)  # Output: True

• Using file.closed is useful to check file state before performing operations, helping avoid errors like writing to a closed file.

Explanation:

• Binary files store data in raw byte format (0s and 1s).
• These bytes can represent anything — images, audio, videos, executables, etc.
• Unlike text files, binary files are not directly human-readable.
• Programs interpret these bytes according to the file type to display or process the content.

Example:

# Writing binary data
data = bytes([120, 3, 255, 0, 100])
with open("binaryfile.bin", "wb") as f:
    f.write(data)

# Reading binary data
with open("binaryfile.bin", "rb") as f:
    content = f.read()
print(content)  # Output: b'x\x03\xff\x00d'

• Here, b'x\x03\xff\x00d' is the byte representation of the data.

Explanation:

• Binary files store data in raw bytes, not in human-readable text.
• A text editor interprets these bytes as ASCII or Unicode characters.
• Since many bytes do not correspond to valid characters, the editor shows random symbols, unreadable characters, or garbage.
• To correctly view or manipulate binary files, specialized programs or binary editors are required.

Example:

# Writing binary data
data = bytes([72, 101, 108, 108, 111, 255])
with open("binaryfile.bin", "wb") as f:
    f.write(data)

• Opening binaryfile.bin in Notepad will show garbled symbols because 255 does not map to a readable ASCII character.

Explanation:

• Python’s io module provides classes and functions for file input/output operations.
• It supports both text and binary files, allowing consistent handling of:
  • Reading: .read(), .readline(), .readlines()
  • Writing: .write(), .writelines()
  • In-memory streams: io.StringIO, io.BytesIO
• While the built-in open() function is commonly used, it internally uses the io module.

Example:

import io

# Writing text using io module
with io.open("example.txt", "w", encoding="utf-8") as f:
    f.write("Hello Mohan\n")

# Reading text using io module
with io.open("example.txt", "r", encoding="utf-8") as f:
    print(f.read())

• Other options:
  • os → Operating system interface (like file deletion or renaming)
  • sys → System-specific parameters
  • file → No such module in Python

Explanation:

• The open() function in Python opens a file and returns a file object (also called a file handle).
• This file object acts as an interface between your program and the file stored on disk.
• Using the file object, you can perform operations like:
  • Reading: .read(), .readline(), .readlines()
  • Writing: .write(), .writelines()
  • Closing: .close()

Example:

# Open a file in write mode
f = open("example.txt", "w")  # f is the file object
f.write("Hello Mohan\n")
f.close()

• Here, f is the file object, which you use to write data to the file.
• Other options are incorrect:
  • File name → not returned
  • File size → not returned
  • File extension → not returned

Explanation:

• In Python, every file object has a closed attribute.
• It indicates whether the file is currently closed:
  • True → the file has been closed
  • False → the file is still open

Example:

f = open("example.txt", "w")
print(f.closed)  # Output: False

f.write("Hello Mohan\n")
f.close()

print(f.closed)  # Output: True

• Checking file.closed is useful to avoid operations on closed files, which would otherwise raise errors.

Explanation:

• In Python, every file object has a mode attribute.
• This attribute tells you how the file was opened:
  • 'r' → read mode
  • 'w' → write mode
  • 'a' → append mode
  • 'rb', 'wb', 'ab' → binary modes
  • 'w+', 'r+', 'a+' → read/write combinations

Example:

f = open("example.txt", "w")
print(f.mode)  # Output: w

f.close()

f = open("example.txt", "rb")
print(f.mode)  # Output: rb
f.close()

• This helps in verifying or debugging the file’s access mode before performing operations.
• Other options are incorrect:
  • File’s data type → not related
  • File name → use file.name instead
  • File offset → use file.tell()

Explanation:

• The 'r' mode in Python opens a file for reading only.
• The file must exist, otherwise Python raises FileNotFoundError.
• Reading starts from the beginning of the file.
• You cannot write to a file opened in 'r' mode.

Other modes for comparison:

• 'w' → write mode (creates file if it doesn’t exist, overwrites if it exists)
• 'a' → append mode (creates file if it doesn’t exist, writes at end)
• 'r+' → read/write mode (file must exist, allows both reading and writing)

Example:

f = open("example.txt", "r")
content = f.read()
print(content)
f.close()

Explanation:

• 'wb' mode stands for write-binary.
• Behavior:
  • If the file exists, its contents are erased before writing.
  • If the file does not exist, a new file is created.
• Binary mode ensures that data is written in raw bytes, not text.

Other modes for comparison:

• 'rb' → read-binary mode, file must exist
• 'ab' → append-binary mode, data is added to end without overwriting
• 'r+' → read/write mode (text by default), file must exist

Example:

# Writing binary data
data = bytes([10, 20, 30])
with open("binaryfile.bin", "wb") as f:
    f.write(data)

• This will overwrite the file if it already exists.

Explanation:

• 'ab+' mode stands for append-binary plus:
  • Opens the file in binary mode.
  • Allows reading (+) and appending (a).
• Behavior:
  • Data is appended at the end of the file.
  • Existing content is preserved; nothing is overwritten.
  • If the file does not exist, a new file is created.

Example:

# Appending binary data and reading
with open("binaryfile.bin", "ab+") as f:
    f.write(bytes([100, 101]))
    f.seek(0)  # Move to beginning for reading
    content = f.read()
    print(content)

• Here, new data is added at the end, but you can still read the full file using .seek(0).

Explanation:

• 'a' mode stands for append:
  • Opens the file for writing only.
  • The file pointer is positioned at the end, so any new data is appended after existing content.
  • If the file does not exist, a new file is created.
• Other modes for comparison:
  • 'r' → file pointer at beginning, read-only
  • 'w' → file is truncated, pointer at beginning
  • 'rb' → read-binary mode, pointer at beginning

Example:

with open("example.txt", "a") as f:
    f.write("Hello Mohan\n")  # Added at end of file

• Existing data in the file remains intact; new content is appended.

Explanation:

• 'w' mode stands for write:
  • Creates a new file if it does not exist.
  • Overwrites existing content if the file already exists.
• Behavior:
  • Data written using 'w' replaces any previous data in the file.
• Other modes for comparison:
  • 'r' → read-only, file must exist
  • 'a' → append, preserves existing data
  • 'rb' → read-binary, file must exist

Example:

with open("example.txt", "w") as f:
    f.write("Hello Mohan\n")  # Overwrites existing content

• If example.txt existed, its previous content is erased.

Explanation:

• If you call open(filename) without specifying a mode, Python uses 'r' by default.
• ‘r’ mode:
  • Opens the file in read-only mode.
  • File must exist, otherwise FileNotFoundError is raised.
  • File pointer starts at the beginning of the file.

Example:

f = open("example.txt")  # Default mode is 'r'
content = f.read()
print(content)
f.close()

• Other modes like 'w', 'a', 'rb' must be explicitly specified.

Explanation:

• 'rb+' mode stands for read and write in binary:
  • Opens an existing binary file for both reading and writing.
  • File pointer starts at the beginning of the file.
  • File must exist, otherwise FileNotFoundError is raised.
• Other modes for comparison:
  • 'r' → read-only (text mode)
  • 'w' → write-only, overwrites file
  • 'a' → append mode
  • 'wb+' → write-binary plus (creates new file if not exist)

Example:

with open("data.bin", "rb+") as f:
    content = f.read()
    print(content)
    f.seek(0)
    f.write(bytes([100, 101]))

• Reads the file first, then writes binary data at the beginning.

Explanation:

• 'wb+' mode stands for write-binary plus:
  • Opens the file in binary mode.
  • Allows both reading and writing.
  • If the file exists, its content is erased.
  • If the file does not exist, a new file is created.
• Other modes for comparison:
  • 'rb+' → read/write binary, does not overwrite, file must exist
  • 'ab+' → append/write binary, adds data at end, preserves existing content
  • 'r+' → read/write text, does not create new file

Example:

with open("binaryfile.bin", "wb+") as f:
    f.write(bytes([10, 20, 30]))  # Overwrites any existing content
    f.seek(0)
    print(f.read())  # Reads the new content

• This mode is useful when you want a fresh binary file but also need to read it immediately.

Explanation:

• In Python, every file object has a name attribute.
• file.name gives the name of the file, including the path if provided.
• Useful for debugging or logging file operations.

Example:

f = open("example.txt", "w")
print(f.name)  # Output: example.txt
f.close()

• Other attributes:
  • file.mode → mode in which the file was opened
  • file.closed → indicates whether the file is closed
  • file.title / file.path → do not exist in Python file objects

Explanation:

• close() method is used to close an open file.
• Closing a file ensures:
  1. All data is flushed from memory to the file.
  2. System resources are released.
  3. Further operations on the file raise an error if attempted.

Example:

f = open("example.txt", "w")
f.write("Hello Mohan\n")
f.close()

print(f.closed)  # Output: True

• Best practice: Always close a file after operations.
• Alternative: Use with statement to automatically close:

with open("example.txt", "w") as f:
    f.write("Hello Mohan\n")
# File automatically closed here

Explanation:

• Calling file.close() terminates the connection between the program and the file.
• Consequences:
  1. File cannot be read from or written to until it is reopened.
  2. Any buffered data is flushed to the file.
  3. System resources associated with the file are released.
• The file itself is not deleted or erased; the data remains intact.

Example:

f = open("example.txt", "w")
f.write("Hello Mohan\n")
f.close()

# Further operations will raise ValueError
# f.write("More text")  # ValueError: I/O operation on closed file

• Best practice: Always close files to avoid resource leaks.
• Alternatively, using with statement automatically closes the file:

with open("example.txt", "w") as f:
    f.write("Hello Mohan\n")
# File is closed automatically here

Explanation:

• Closing a file using close() ensures that:
  1. Any unsaved or buffered data is written (flushed) to the disk.
  2. Memory resources associated with the file are released.
• Not closing a file can lead to:
  • Data loss if buffered data isn’t written.
  • Resource leaks, which may affect program performance.
• Best practice: Use with statement to automatically handle closing:

with open("example.txt", "w") as f:
    f.write("Hello Mohan\n")
# File is automatically closed here

• This ensures safe and efficient file handling.

Explanation:

• In Python, file objects are managed by references.
• Reassigning a variable pointing to a file object (e.g., f = open("file2.txt")) does not automatically close the previous file (file1.txt).
• If the previous file isn’t closed using f.close(), it remains open and may lead to:
  • Data not flushed properly
  • Resource leaks
• Best practice: Always close files explicitly or use the with statement:

# Incorrect way (can leave file open)
f = open("file1.txt", "w")
f = open("file2.txt", "w")  # file1.txt is still open!

# Correct way
f = open("file1.txt", "w")
f.write("Hello Mohan\n")
f.close()

f = open("file2.txt", "w")
f.write("Another file\n")
f.close()

# Or use 'with' to auto-close
with open("file1.txt", "w") as f:
    f.write("Hello Mohan\n")

Key Point: Python garbage collector may eventually close the file, but relying on this is unsafe.

Explanation:

• The with statement is a context manager in Python.
• Benefits of using with for file handling:
  1. Automatically calls file.close() at the end of the block.
  2. Ensures resources are released, even if exceptions occur.
  3. Makes code cleaner and safer than manually opening and closing files.

Example:

with open("example.txt", "w") as f:
    f.write("Hello Mohan\n")
# File is automatically closed here

• Without with, you’d have to manually call f.close().

Explanation:

• The with statement is used as a context manager to handle files safely.
• Correct syntax:

with open("example.txt", "r") as f:
    content = f.read()
# File is automatically closed after this block

• Key Points:
  1. open(file_name, mode) → opens the file with the specified mode ('r', 'w', 'a', etc.).
  2. as file_object → assigns the file object to a variable for operations inside the block.
  3. Automatic closure occurs even if an error is raised inside the block.
• This syntax eliminates the need to manually call close().

Explanation:

• The with statement in Python acts as a context manager.
• Benefits:
  1. Automatic closure: The file is closed automatically after the indented block is executed.
  2. Error safety: Even if an exception occurs inside the block, the file is closed safely.
  3. Cleaner code: No need to explicitly call file.close().
• Usage: Can be used for both text and binary files.

Example:

with open("example.txt", "r") as f:
    content = f.read()
# File is automatically closed here

• This ensures efficient resource management and prevents file corruption.

Explanation:

• The "r+" mode in Python:
  1. Opens the file for both reading and writing.
  2. File must exist; otherwise, it raises FileNotFoundError.
  3. Reading/writing starts from the beginning of the file.
• Difference from other modes:
  • 'r' → read-only
  • 'w' → write-only (overwrites existing content)
  • 'a' → append (write at end)
  • 'r+' → read/write (does not overwrite automatically)

Example:

with open("myfile.txt", "r+") as f:
    print(f.read())         # Read existing content
    f.write("\nHello Mohan") # Append data starting at current pointer

• This mode is useful when you need to read and modify a file without erasing existing content.

Explanation:

• The 'w' mode in Python:
  1. Opens a file for writing only.
  2. If the file exists, its entire content is erased.
  3. If the file does not exist, a new empty file is created.
• Use case: Suitable when you want to replace old content with new data.

Example:

# Existing file example.txt has "Old content"
f = open("example.txt", "w")
f.write("Hello Mohan\n")  # Overwrites old content
f.close()

• After execution, the file contains only "Hello Mohan\n"; old content is lost.

Explanation:

• In append mode 'a':
  1. The file pointer is automatically positioned at the end of the file.
  2. New data is added after existing content.
  3. Existing content is never overwritten.
• Behavior if file doesn’t exist:
  • Python creates a new empty file.

Example:

with open("example.txt", "a") as f:
    f.write("Hello Mohan\n")  # Added at the end of existing file content

• Append mode is ideal for log files or data collection files where preserving existing content is important.

Explanation:

• 'a+' mode in Python:
  1. Opens the file for both reading and appending.
  2. The file pointer is positioned at the end of the file for writing.
  3. Existing content is not overwritten.
  4. You can read the file, but new data is always added at the end.
• Difference from 'r+':
  • 'r+' allows reading and writing starting from the beginning, overwriting data if written.
  • 'a+' preserves existing content and writes only at the end.

Example:

with open("example.txt", "a+") as f:
    f.write("New line added\n")  # Appended at the end
    f.seek(0)                     # Move pointer to start to read
    print(f.read())                # Reads the entire file content

Explanation:

• The with statement in Python is a context manager.
• Key points:
  1. Automatically calls file.close() at the end of the block.
  2. Prevents memory/resource leaks by ensuring the file is properly closed.
  3. Improves code readability and reduces errors.
• Statement B is incorrect because manual closing is not needed when using with.

Example:

with open("example.txt", "r") as f:
    data = f.read()
# File is automatically closed here

• No f.close() is required; Python handles it internally.

Explanation:

• 'a+' mode in Python:
  1. Opens the file for reading and appending.
  2. The file pointer is positioned at the end of the file for writing.
  3. Existing content is preserved; new data is added after existing data.
  4. Reading is allowed after moving the pointer using seek().

Example:

f = open("data.txt", "a+")
f.write("Hello Mohan\n")  # Appended at the end
f.seek(0)                  # Move pointer to start for reading
print(f.read())             # Reads entire file
f.close()

• Ideal for log files or data collection where existing content must not be lost.

Explanation:

• The with statement is a context manager in Python.
• Advantages over separate open() and close() calls:
  1. Automatic resource management: Ensures the file is closed automatically even if exceptions occur.
  2. Reduces syntax errors: No need to remember file.close() manually.
  3. Cleaner and more readable code: Indentation clearly shows the scope of file operations.
• Example:

with open("example.txt", "r") as f:
    data = f.read()
# File is automatically closed here

• Using open() and close() separately could lead to resource leaks if close() is forgotten or an error occurs before it is called.

Explanation:

• The with statement in Python acts as a context manager.
• Behavior during exceptions:
  1. When an exception occurs inside the with block, Python ensures the file is properly closed before propagating the exception.
  2. This prevents resource leaks and keeps file handling safe.
• Example:

try:
    with open("example.txt", "r") as f:
        data = f.read()
        raise Exception("Something went wrong")
except Exception as e:
    print(e)
# File is automatically closed despite the exception

• Even though an exception is raised, example.txt is closed safely, ensuring proper resource management.

Explanation:

• The write() method writes a single string to a file.
• Key points:
  1. Takes a string as an argument and writes it to the file.
  2. Returns the number of characters written.
  3. Does not automatically add a newline; you must include \n explicitly if needed.
• Difference from writelines():
  • writelines() writes a list of strings to the file, without adding newlines automatically.

Example:

with open("example.txt", "w") as f:
    chars_written = f.write("Hello Mohan\n")
print(chars_written)  # Output: 12 (number of characters written)

• Here, "Hello Mohan\n" is written as a single string into the file.

Mohan Exam

Explanation:

• When using file.write(string):
  1. It writes the string to the file.
  2. Returns an integer representing the number of characters successfully written.
  3. Includes all characters, including newline characters (\n) if present.
• Example:

with open("example.txt", "w") as f:
    chars_written = f.write("Hello Mohan\n")
print(chars_written)  # Output: 12

• Useful to verify how many characters were written to the file.

Explanation:

Concept Behind the Code

1. open(“demo.txt”, “w”)
   • Opens a text file named demo.txt in write mode ("w").
   • If the file already exists, its old content is erased.
   • If it doesn’t exist, a new file is created.
2. write(“Python\nFile Handling”)
   • Writes the given string to the file.
   • Returns an integer — the number of characters successfully written.
   • \n is a single newline character, not two separate characters.
3. print(x)
   • Prints the return value of the write() method, i.e., the number of characters written to the file.
4. myfile.close()
   • Closes the file and ensures all data is properly saved.

Counting the Characters

Let’s count the number of characters in "Python\nFile Handling":

Character	Count
P	1
y	2
t	3
h	4
o	5
n	6
\n (newline)	7
F	8
i	9
l	10
e	11
(space)	12
H	13
a	14
n	15
d	16
l	17
i	18
n	19
g	20

Total characters = 20

Important Note

\n is counted as a single character (newline), not as two separate symbols (\ and n).
Hence, the total number of characters in the string is 20.

You can verify this using:

len("Python\nFile Handling")  # Output: 20

Final Output

20

Explanation:

• In Python strings, \n is known as the newline character.
• It instructs the program to move the cursor to the next line, thereby marking the end of the current line.
• When the string "Hello\nWorld" is written to a file, it appears as:

Hello
World

Here, \n creates a line break between “Hello” and “World”.

Key Points

1. \n → newline (end of line)
2. \t → tab space
3. \0 → null character (in C, not typically used in Python)
4. EOF → end of file (not represented by \n)

Example

with open("example.txt", "w") as f:
    f.write("Hello\nWorld")

Content inside the file:

Hello
World

Explanation:

• The write() method in Python accepts only string-type data as input.
• If you try to write numeric data (like an integer or float) directly using write(), Python will raise a TypeError, because integers cannot be written to a file without conversion.

Example

with open("data.txt", "w") as f:
    f.write(123)   # This will cause an error

Output:

TypeError: write() argument must be str, not int

Correct Way

To write numeric data, you must convert it to a string using the str() function:

with open("data.txt", "w") as f:
    f.write(str(123))   # Works correctly

File content:

123

Key Point

• write() → accepts only string type.
• For numbers or other data types, use type conversion (str()) before writing.
• For structured data, Python provides pickle or JSON modules.

Explanation:

• The write() method in Python only accepts string-type data.
• If you try to pass an integer directly (as in myfile.write(123)), Python will raise a TypeError, because the method expects a string.
• To write numeric data successfully, you must convert the number to a string using the str() function.

Example

myfile = open("demo.txt", "w")
myfile.write(str(123))   # Correct way
myfile.close()

Content of demo.txt:

123

If you try:

myfile.write(123)   # Incorrect

Python will show:

TypeError: write() argument must be str, not int

Key Points

• write() → accepts only string input.
• To write numbers → convert using str().
• writelines() also requires a sequence of strings, not integers.
• Functions like pickle.dump() or json.dump() can write non-string objects, but in text files, conversion is necessary.

Explanation:

• In Python, file operations are buffered.
  • When data is written using write(), it is first stored in an in-memory buffer.
  • It may not be immediately written to the physical file on disk.
• The flush() method forces the buffer to write its content to the file immediately, without closing the file.
• This is useful when you want to ensure that all written data is physically saved to the file while the program is still running.

Example

with open("demo.txt", "w") as f:
    f.write("Hello World")
    f.flush()   # Forces the buffer to write "Hello World" to demo.txt immediately
    # File is still open here

Explanation:

• Without flush(), data may remain in memory temporarily until the file is closed or the buffer is full.
• flush() ensures data integrity especially in long-running programs or logging scenarios.

Key Points

• flush() does not close the file.
• It does not erase data.
• The file pointer remains unchanged; only the buffer is cleared by writing its content.

Explanation:

• The writelines() method in Python is used to write multiple strings to a file sequentially.
• It accepts an iterable (like a list, tuple, or generator) containing string elements.
• Unlike write(), writelines() does not add newline characters automatically. If you want each string on a new line, you must include \n explicitly in the strings.

Example

lines = ["Hello\n", "World\n", "Python\n"]
with open("demo.txt", "w") as f:
    f.writelines(lines)

Content of demo.txt:

Hello
World
Python

Explanation:

• Each element of the list is written in sequence.
• No extra characters or separators are added automatically.

Key Points

• write() → writes a single string.
• writelines() → writes multiple strings from an iterable.
• To write each string on a new line, include \n in each element of the iterable.

Explanation:

• write():
  • Writes a single string to a file.
  • Returns the number of characters written.
  • Example: with open("demo.txt", "w") as f: f.write("Hello World\n")
• writelines():
  • Writes multiple strings passed as an iterable (like a list, tuple, or generator).
  • Does not add newline characters automatically, so \n must be included if needed.
  • Example: lines = ["Hello\n", "World\n", "Python\n"] with open("demo.txt", "w") as f: f.writelines(lines)

Key Points

Method	Accepts	Writes	Newline Added Automatically?
write()	Single string	One string	No
writelines()	Iterable of strings	All strings in the iterable	No

• write() → ideal for single string writing.
• writelines() → ideal for writing multiple lines at once.

Explanation:

• When a file is opened in write mode ('w'), Python prepares the file to overwrite existing content.
• Each call to write() writes the provided string sequentially to the file at the current file pointer location.
• The file pointer moves forward after each write, so multiple calls to write() will append data in sequence within the same open session.
• The content will remain in the file after it is closed.

Example

with open("demo.txt", "w") as f:
    f.write("Hello\n")
    f.write("World\n")

Content of demo.txt:

Hello
World

Explanation:

• The first write() writes "Hello\n".
• The second write() writes "World\n" immediately after the first string.
• Both strings are preserved sequentially in the file.

Key Points

• Write mode ('w') erases previous content at the start, but subsequent writes in the same session are appended sequentially.
• To overwrite content, the file must be reopened in 'w' mode again.
• write() does not automatically add a newline; it must be included if needed (\n).

Explanation:

• In Python, file operations are buffered for efficiency.
• When write() is called, the data is first stored in a memory buffer instead of being written directly to the disk.
• The buffer improves performance by reducing the number of disk writes.
• Data in the buffer is written to the physical file when:
  1. The file is closed using close().
  2. flush() is explicitly called to force writing immediately.
  3. The buffer is full (depending on the system and Python implementation).

Example

with open("demo.txt", "w") as f:
    f.write("Hello World")  # Data goes to buffer first
    f.flush()               # Buffer is written to disk immediately

• Without flush(), data would still be written to disk automatically when f is closed.

Key Points

• Buffering improves efficiency by reducing frequent disk writes.
• flush() can be used to manually write the buffer contents to disk.
• Closing the file also automatically flushes the buffer.

“BufferedWriter writes data to a buffer, which is then written to the underlying raw stream, improving efficiency.”

Explanation:

• In Python, file operations are buffered for efficiency.
• Data written using write() is first stored in a memory buffer and may not immediately appear in the physical file.
• Using flush() forces the buffer to write its contents to disk immediately, ensuring that even partially written data is saved.
• This is particularly important in situations such as:
  • Logging large files in real-time.
  • Data streaming or monitoring applications where updates must be visible immediately.
• Without flush(), the data may remain in memory until the buffer fills up or the file is closed.

Example

with open("log.txt", "w") as f:
    for i in range(1000):
        f.write(f"Line {i}\n")
        f.flush()  # Ensures each line is immediately written to disk

Explanation:

• Each line is written and flushed immediately.
• This ensures that even if the program crashes, the most recent lines are saved.

Key Points

• flush() is not needed if the file is closed normally, as close() automatically flushes the buffer.
• It is required when data must be visible immediately on disk before closing.

“Flush the write buffer of the stream if applicable. This ensures that data is written to the underlying raw stream immediately.”

Explanation:

• The writelines() method writes all elements of an iterable (like a list or tuple) sequentially to the file.
• Each string in the iterable is written exactly as it is.
• Since the strings in data include \n, each line will appear on a new line in the file.

Example

Content of info.txt after execution:

Line1
Line2
Line3

• The first element "Line1\n" is written.
• Then "Line2\n" and "Line3\n" are written sequentially.
• No TypeError occurs because writelines() accepts an iterable of strings.

Key Points

• writelines() does not automatically add newlines. If newlines are needed, they must be included in the strings (as done here with \n).
• write() writes one string at a time, whereas writelines() writes multiple strings from an iterable.

“writelines(lines) writes each element of the given iterable to the stream in order.”

Explanation:

• The writelines() method writes all elements of an iterable (like a list or tuple) sequentially to a file.
• Important points about writelines():
  1. It does not add newline characters automatically.
  2. Each string in the iterable is written exactly as provided.
  3. If a newline is desired, it must be included in the string itself, e.g., "Line1\n".

Example

lines = ["Hello\n", "World\n", "Python"]
with open("demo.txt", "w") as f:
    f.writelines(lines)

Content of demo.txt:

Hello
World
Python

Explanation:

• "Hello\n" → newline included
• "World\n" → newline included
• "Python" → no newline, so it stays on the same line if appended

• writelines() does not automatically insert \n between elements.
• This is a common misconception; newline must be part of each string if needed.

Key Points

• write() → writes single string
• writelines() → writes multiple strings from an iterable, no automatic newlines
• Always include \n in strings if a new line is needed

“writelines(lines) writes a list or any iterable of strings to the stream. There is no separator or newline added automatically.”

Explanation:

• In Python, file operations are buffered to improve performance.
• When write() is called:
  1. The data is first stored in a memory buffer (RAM).
  2. Later, it is written to the physical file on disk either when:
     • The file is closed using close().
     • flush() is explicitly called.
     • The buffer becomes full (depending on system and implementation).
• This buffering mechanism reduces frequent disk writes, improving efficiency.

Example

with open("demo.txt", "w") as f:
    f.write("Hello World")  # Data goes to RAM buffer first
    f.flush()               # Forces the buffer to write data to disk immediately

• Without flush(), the data would still be written to disk automatically when the file is closed.

Key Points

• Buffering stores data temporarily in RAM before writing to disk.
• flush() can be used to manually write the buffer content.
• Closing the file automatically flushes the buffer.

“BufferedWriter writes data to a memory buffer, which is then written to the underlying raw stream, improving efficiency.”

Explanation:

• Append mode 'a' in Python:
  • Opens a file for writing at the end of the file.
  • Existing content is preserved.
  • The file pointer is placed after the last character, so any new data is added after the old content.
• When the file is closed and reopened in read mode 'r', all content, including the newly appended "Hello", can be read.

Example

Suppose data.txt initially contains:

Line1
Line2

# Append mode
with open("data.txt", "a") as f:
    f.write("Hello\n")

# Read mode
with open("data.txt", "r") as f:
    print(f.read())

Output:

Line1
Line2
Hello

• "Hello" is added at the end.
• Old content is not erased.

Key Points

• 'a' mode → append at end, preserves existing data.
• 'w' mode → overwrite, erases existing content.
• Always close the file to ensure data is written and saved.

“Opening a file in append mode 'a' positions the file pointer at the end of the file. Data written is added after existing content.”

Explanation:

• The write() method in Python is used to write data to a file.
• Important points about write():
  1. Only string data is allowed.
     • Numeric or other types must be converted using str() before writing.
  2. It does not automatically add newlines.
     • If you need a newline, include \n explicitly.
  3. It does not require flush(), but calling flush() ensures data is immediately written from buffer to disk.

Example

with open("demo.txt", "w") as f:
    f.write("Hello World\n")         # Works
    f.write(str(123) + "\n")         # Numeric converted to string
    # f.write(123)                  # TypeError

Content of demo.txt:

Hello World
123

Key Points

• write() → writes a single string to the file.
• For multiple strings → use writelines() or multiple write() calls.
• Always include \n if a new line is needed.

“write(s) writes the string s to the stream. s must be a string, not an integer or other type.”

Explanation:

• In Python, file operations are buffered for efficiency.
• When you use write(), the data is first stored in a RAM buffer, not immediately written to disk.
• If the file is not closed properly:
  • Some data in the buffer may not be written to the file.
  • This can lead to loss of recent writes.
• Proper ways to ensure data is written:
  1. Call close() explicitly.
  2. Use a with statement, which automatically closes the file at the end of the block.
  3. Call flush() to manually write the buffer to disk.

Example

f = open("demo.txt", "w")
f.write("Hello World")  # Data goes to buffer
# f.close()  # If forgot, data may remain in buffer

• If the file is not closed, "Hello World" may not appear in demo.txt.

# Correct way
with open("demo.txt", "w") as f:
    f.write("Hello World")  # Automatically flushed and closed

Key Points

• Always close files after writing to avoid data loss.
• Using with statement is recommended for safety.
• Forgetting to close files can leave data in buffer, especially in large files or long-running programs.

“It is important to close the file after writing, otherwise buffered data may not be saved.”

Explanation:

• In Python, \n is a single character representing a newline.
• When written to a file using write():
  • It moves the cursor to the next line.
  • It is counted as one character in the total character count returned by write().
• Even though it creates a new line visually, internally it is just one character in the file.

Example

text = "Hello\nWorld"
with open("demo.txt", "w") as f:
    chars_written = f.write(text)
print(chars_written)  # Output: 11

• "Hello" → 5 characters
• \n → 1 character
• "World" → 5 characters
• Total = 11 characters

Key Points

• \n is a single character in Python strings.
• Always include \n explicitly if a new line is required in file writing.
• write() returns the total number of characters written, counting \n as 1.

“\n represents a single newline character in strings.”

Explanation:

• write():
  • Writes a single string to a file.
  • Returns the number of characters written.
  • Newlines must be included explicitly using \n.
• writelines():
  • Writes multiple strings from an iterable (like a list or tuple) sequentially to a file.
  • Does not automatically add newlines; they must be part of the strings.
• Both methods are used only for writing operations.
• Neither reads data, deletes data automatically, nor closes files; closing must be done explicitly or via a with statement.

Example

# write() example
with open("demo.txt", "w") as f:
    f.write("Hello\n")

# writelines() example
lines = ["Line1\n", "Line2\n", "Line3\n"]
with open("demo.txt", "a") as f:
    f.writelines(lines)

Content of demo.txt:

Hello
Line1
Line2
Line3

• write() → wrote "Hello\n"
• writelines() → wrote all strings in the list sequentially

Key Points

• write() → writes one string
• writelines() → writes multiple strings from an iterable
• Both methods are writing operations only

“write() writes a single string to the stream. writelines() writes a sequence of strings to the stream.”

Explanation:

• writelines() writes all elements of an iterable (like a list or tuple) sequentially to a file.
• Unlike write(), it does not return the number of characters written.
• Its return value is always None.
• Use write() if you want to know how many characters were written.

Example

lines = ["Line1\n", "Line2\n", "Line3\n"]
with open("info.txt", "w") as f:
    result = f.writelines(lines)

print(result)  # Output: None

• All strings in lines are written to info.txt.
• result is None — no count of characters is returned.

Key Points

• writelines() → writes multiple strings, returns None
• write() → writes single string, returns number of characters written
• Always include \n in strings if a newline is desired

“writelines(lines) writes each element of the iterable to the stream. It returns None.”

Explanation:

• writelines() writes all elements of an iterable (like a list or tuple) sequentially to a file.
• Important points:
  1. It does not automatically add newlines; if you want line breaks, include \n in the strings.
  2. It can handle multiple strings at once.
  3. The method returns None.
  4. Only strings in the iterable are allowed; other data types must be converted using str().

Example

lines = ["Line1\n", "Line2\n", "Line3\n"]
with open("info.txt", "w") as f:
    f.writelines(lines)

Content of info.txt:

Line1
Line2
Line3

• All three strings are written sequentially.
• Newlines appear because \n is explicitly included.

Key Points

• writelines() → writes multiple strings from an iterable
• No automatic newline insertion
• Returns None

“writelines(lines) writes each element of the given iterable to the stream. No separator or newline is added automatically.”

Explanation:

• writelines() requires an iterable of strings (like a list or tuple of strings).
• If you pass numbers (integers or floats) directly:
  • Python cannot write them as-is.
  • A TypeError is raised: "write() argument must be str, not int"
• To write numbers, convert them to strings using str() first.

Example

numbers = (1, 2, 3)

with open("demo.txt", "w") as f:
    # f.writelines(numbers)  # Raises TypeError
    f.writelines([str(n) + "\n" for n in numbers])  # Works

Content of demo.txt after conversion:

1
2
3

• Each number is converted to a string and written successfully.

Key Points

• writelines() → iterable of strings required
• Numbers must be converted with str()
• Passing non-string types → TypeError

“Each element of the iterable must be a string. Otherwise, a TypeError is raised.”

Explanation:

• In Python, the mode in which a file is opened determines the operations allowed:

Mode	Read Allowed	Write Allowed	Notes
'r'	Yes	No	Read-only; file must exist
'r+'	Yes	Yes	Read and write; file must exist
'w+'	Yes	Yes	Read and write; overwrites file or creates new
'a+'	Yes	Yes	Read and append; creates new if file doesn’t exist
'w'	No	Yes	Write-only; overwrites file
'wb'	No	Yes	Write-only binary mode

• Key point: Only modes that allow reading can be used to read file contents.
• Modes 'w' and 'wb' are write-only, so reading is not allowed.

Example

# Open file in 'r+' mode to read and write
with open("demo.txt", "r+") as f:
    content = f.read()
    print(content)

• 'r+' allows both reading and writing.
• 'w+' or 'a+' would also allow reading, but 'w+' overwrites existing content.

Key Points

• To read file contents, use:
  • 'r' → read-only
  • 'r+' → read/write
  • 'w+' → read/write (overwrites file)
  • 'a+' → read/append

“Text files can be opened in modes that allow reading (r, r+, w+, a+). Write-only modes do not allow reading.”

Explanation:

• read(n) is a method used to read data from a file.
• Behavior:
  1. Reads n characters (for text files) or n bytes (for binary files) from the current file pointer position.
  2. If n is omitted or negative, the entire file is read.
  3. The file pointer moves forward by n characters after reading.
• This is useful when you want to read a portion of a file instead of loading the whole file into memory.

Example

with open("demo.txt", "r") as f:
    content = f.read(5)  # Reads first 5 characters
    print(content)

• If demo.txt contains "Hello World", output will be:

Hello

• The next call to f.read(5) will read the next 5 characters: " Worl"

Key Points

• read(n) → reads n characters/bytes from current pointer
• File pointer advances automatically
• Use read() without argument to read entire file

“f.read(n) reads at most n characters (or bytes) from the file; if n is negative or omitted, the whole file is read.”

Explanation:

read(10) reads the first 10 characters from the file, which are "Hello ever".

• read(n) reads n characters from the current file pointer.
• In the given code:
  1. File content: "Hello everyone"
  2. read(10) → reads first 10 characters from the start.
• Counting characters:

Characters	H	e	l	l	o	(space)	e	v	e	r	y	o	n	e
Position	1	2	3	4	5	6	7	8	9	10	11	12	13	14

• First 10 characters = "Hello ever"
• File pointer moves to the 11th character after reading.

Example Run

with open("myfile.txt", "r") as f:
    print(f.read(10))

Output:

Hello ever

Key Points

• read(n) → reads exactly n characters (or fewer if end-of-file is reached)
• File pointer advances automatically
• Useful for partial file reading

“f.read(n) reads at most n characters from the file; if the end of file is reached, fewer characters may be returned.”

Explanation:

• read(n) reads n characters from the current file pointer.
• When n is omitted or negative (-1):
  • Python reads all remaining content from the current file pointer to the end of the file.
• This is useful when you want to load the whole file into memory at once.

Example

with open("demo.txt", "r") as f:
    content = f.read()  # or f.read(-1)
    print(content)

• If demo.txt contains:

Hello World
Welcome to Python

• Output:

Hello World
Welcome to Python

• The entire content is read in one call.

Key Points

• read() without arguments → reads entire file
• read(-1) → behaves the same as no argument
• File pointer moves to end of file after reading

“If n is omitted or negative, all data until EOF is read.”

Explanation:

• read() without any argument:
  • Reads all content from the current file pointer to the end of file.
  • Equivalent to read(-1).
• Important points about other methods:
  1. writelines() → Does not add newline characters automatically. Newlines must be part of the strings.
  2. read(n) → n must be non-negative; negative values (or omission) read the entire file.
  3. write() → Can write strings, but cannot write non-string types unless converted with str().

Example

with open("demo.txt", "r") as f:
    content = f.read()
    print(content)

• If demo.txt contains:

Hello World
Welcome to Python

• Output:

Hello World
Welcome to Python

• The entire file content is read in a single call.

Key Points

• read() with no argument → reads entire file
• writelines() → writes multiple strings, no automatic newline
• write() → writes strings only
• read(n) → reads n characters

“If no argument is provided to read(), the entire file is read from the current pointer.”

Explanation:

file.read() without arguments

• Reads the entire content of the file from the current file pointer position to the end of the file (EOF).
• The file pointer automatically moves to the end of file after reading.
• This is the standard method to read a whole file in NCERT examples.

Example Usage

with open("demo.txt", "r") as f:
    content = f.read()  # Reads the entire file
    print(content)

• If demo.txt contains:

Hello World
Python File Handling

Output:

Hello World
Python File Handling

• The entire content is read and printed.

Key Points

• read() without arguments → reads all remaining content from the current pointer.
• read(n) → reads n characters only.
• Always use read() when you want complete file content.

“Calling read() without any argument reads the entire content of the file.” 
“If no argument is provided to read(), all data is read until EOF.”

Explanation:

1. About the code:
   • A list named lines is created containing three strings.
   • Each string ends with a newline character \n.
   • The file is opened in write mode 'w', which creates a new file or overwrites an existing one.
   • writelines(lines) writes each string in the list to the file sequentially.
   • close() saves and closes the file properly.
2. How writelines() works:
   • It writes each element of the iterable (like list or tuple) to the file exactly as it is given.
   • It does not add newline characters automatically, so you must include \n manually if you want each string to appear on a new line.
3. Since each string already ends with \n, the content in myfile.txt will appear as:

Hello everyone
Writing multiline strings
This is the third line

Key Concept Recap

Method	Description	Automatically adds \n?
write()	Writes a single string	No
writelines()	Writes multiple strings from an iterable	No (need to include \n manually)

“The writelines() function writes a sequence of strings to a file. It does not add newline characters automatically.”

Explanation:
writelines() does not add newlines. Without \n, all strings are written consecutively on a single line.

Explanation:

• The 'a+' mode in Python opens the file for both appending and reading.
• The file pointer is positioned at the end of the file when opened.
• You can append new data at the end and also read data (after moving the pointer if needed using seek()).

Example:

f = open("file.txt", "a+")
f.write("New data\n")
f.seek(0)
print(f.read())
f.close()

This code appends text and then reads the entire file successfully.

Why other options are incorrect:

Mode	Meaning	Read Allowed?	Append Allowed?
'w'	Write only	No	No
'a'	Append only	No	Yes
'a+'	Append + Read	Yes	Yes
'wb'	Binary Write	No	No

Explanation:

• The read() method is used to read the contents of a file in text or binary mode.
• When called without arguments, it reads the entire remaining content of the file.
• When called with an argument n, it reads exactly n characters (in text mode) or n bytes (in binary mode) from the current file pointer.

Example 1:

f = open("sample.txt", "r")
print(f.read(5))   # Reads first 5 characters
print(f.read())    # Reads the rest of the file
f.close()

If file contains:

Python File Handling

Output:

Pytho
n File Handling

Key Points:

• read() with no argument → reads entire file.
• read(n) → reads exactly n characters or bytes.
• Both return a string (in text mode), not a list.
• After reading, the file pointer moves forward by n positions.

“The read() function reads the whole file, whereas read(n) reads only n characters (or bytes in binary mode) starting from the current file pointer.”

Explanation:

A. read() moves the file pointer

When read() or read(n) is called on a file, the file pointer automatically moves forward by the number of characters (or bytes) read. This pointer indicates where the next read or write operation will start.

Example:

f = open("demo.txt", "r")
data = f.read(5)
print(f.tell())   # Output: 5
f.close()

Here, f.tell() shows that the pointer has moved to position 5 after reading 5 characters.

B. writelines() returns number of characters

This statement is incorrect. The writelines() method does not return any value. It only writes all strings from an iterable (like a list or tuple) to the file. Its return value is always None.

Example:

f = open("demo.txt", "w")
result = f.writelines(["Hello", "World"])
print(result)
f.close()

Output:

None

C. read(n) reads n characters

The read(n) method reads exactly n characters (or n bytes in binary mode) from the current file pointer position. If fewer than n characters remain, it reads until the end of the file.

Example:

f = open("demo.txt", "r")
print(f.read(6))
f.close()

If the file contains "Python", the output will be:

Python

D. writelines() can write multiple strings

The writelines() method writes all elements from an iterable of strings to the file sequentially. It does not add newline characters automatically; if line breaks are required, \n must be included in the strings.

Example:

lines = ["Line1\n", "Line2\n", "Line3\n"]
f = open("data.txt", "w")
f.writelines(lines)
f.close()

File content:

Line1
Line2
Line3

Final Conclusion

Option	Statement	Correctness	Explanation
A	read() moves the file pointer	Correct	Pointer moves automatically after reading
B	writelines() returns number of characters	Incorrect	Returns None, not character count
C	read(n) reads n characters	Correct	Reads n characters or bytes
D	writelines() can write multiple strings	Correct	Writes all strings from an iterable

Explanation:

• The 'r' mode in Python is used for reading an existing file.
• It requires the file to exist before opening.
• If the file does not exist, Python cannot read it, and hence it raises a FileNotFoundError.
• The 'r' mode does not create a new file automatically.

Example:

f = open("nonexistent.txt", "r")

Output:

FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent.txt'

• To create a new file if it doesn’t exist, you would use 'w', 'a', or 'x' modes instead.
• The 'r+' mode also requires the file to exist, otherwise it raises the same error.

“When a file is opened in read mode ('r'), it must exist. If it does not, Python raises an exception.”

Explanation:

• The readline() method in Python is used to read a single line from a file.
• The optional parameter n specifies the maximum number of characters to read from that line.
• If the newline character (\n) is encountered before reaching n characters, readline(n) stops reading and returns the characters including the newline.
• If the line has fewer than n characters, the entire line is returned.

Example 1: Without n

f = open("demo.txt", "r")
line = f.readline()
print(line)
f.close()

• Output: Returns the first line entirely, including \n.

Example 2: With n

f = open("demo.txt", "r")
line = f.readline(5)
print(line)
f.close()

• Output: Returns at most first 5 characters of the first line, or less if a newline occurs sooner.

Key Points:

• Only reads one line at a time.
• readline() with n does not read multiple lines; it stops at the newline or after n characters.

“The readline() method reads one line at a time. An optional argument n specifies the maximum number of characters to read from that line.”

Explanation:

• The readline() method reads one line at a time from the file.
• When called without any argument, it reads the entire line from the current file pointer position until the newline character (\n) is encountered.
• The returned string includes the newline character at the end of the line (except for the last line if the file does not end with \n).
• readline() does not read the entire file; multiple calls are required to read successive lines.

Example:

f = open("demo.txt", "r")
line = f.readline()
print(repr(line))
f.close()

If the first line of demo.txt is:

Hello World

Output:

'Hello World\n'

Key Points:

• Returns a string, not a list.
• To read all lines into a list, use readlines() instead.
• Each call to readline() advances the file pointer to the start of the next line.

“The readline() method reads a single line including the trailing newline character.”

Explanation:

• The readline() method reads a single line from a file.
• When the file pointer reaches the end of the file, there are no more lines to read.
• In this case, readline() returns an empty string ('').
• This behavior is useful when iterating through a file line by line, allowing loops to stop when EOF is reached.

Example:

f = open("demo.txt", "r")
while True:
    line = f.readline()
    if line == '':
        break
    print(line, end='')
f.close()

• The loop terminates when readline() returns '' at the end of the file.

Key Points:

• readline() does not raise an error at EOF.
• Returning '' differentiates between an actual empty line ('\n') and the end of file.

“The readline() method returns an empty string when the end of file is reached.”

Explanation:

• The readline(n) method reads up to n characters from the current line.
• If a newline character (\n) occurs before n characters, reading stops there. Otherwise, it reads exactly n characters.
• In this example:
  • The first line is "Hello everyone\n"
  • readline(10) reads the first 10 characters starting from the beginning: "Hello ever"

Character counting for clarity:

H e l l o   e v e r y o n e \n
1 2 3 4 5 6 7 8 9 10 ...

• The first 10 characters are "Hello ever".
• To read the entire line, you can use readline() without any argument.

Example for reading the full line:

f = open("myfile.txt", "r")
print(f.readline())
f.close()

• Output: "Hello everyone\n"

“The readline(n) method reads at most n characters from the current line, including the newline character if it occurs before n characters.”

Explanation:

• The readline() method is used to read one line at a time from a file.
• When iterating over a file using a loop with readline(), each iteration returns the next line until the end of the file (EOF) is reached.
• This is useful when processing large files line by line, as it avoids loading the entire file into memory at once.

Example:

f = open("demo.txt", "r")
while True:
    line = f.readline()
    if line == '':
        break
    print(line, end='')
f.close()

• Here, readline() reads each line sequentially.
• The loop stops when readline() returns an empty string '', indicating EOF.

Key Points:

• readline() returns a string, not a list.
• To read all lines at once into a list, readlines() should be used.
• Each call to readline() advances the file pointer to the start of the next line.

“Using readline() in a loop allows reading a file one line at a time, which is efficient for processing large files.”

Explanation:

• The readlines() method reads the entire file from the current file pointer position.
• It returns a list of strings, where each element corresponds to one line of the file, including the newline character \n.
• This method is useful when you want to process all lines at once.

Example:

f = open("demo.txt", "r")
lines = f.readlines()
print(lines)
f.close()

If demo.txt contains:

Line 1
Line 2
Line 3

Output:

['Line 1\n', 'Line 2\n', 'Line 3\n']

Key Points:

• Unlike readline(), which returns one line at a time, readlines() returns all lines at once as a list.
• Newline characters are preserved; if you want to remove them, you can use strip() or list comprehension.

“The readlines() method reads all lines of a file and returns them as a list of strings.”

Explanation:

• The readlines() method reads all lines from a file and returns them as a list of strings.
• Each line in the list includes the newline character (\n) at the end (except possibly the last line if the file does not end with a newline).
• This behavior differentiates it from methods that process lines without including \n.

Example:

f = open("demo.txt", "r")
lines = f.readlines()
print(lines)
f.close()

If demo.txt contains:

Hello
World
Python

Output:

['Hello\n', 'World\n', 'Python\n']

Key Points:

• readlines() does not remove newline characters automatically.
• Each element of the returned list is a string representing one line of the file.
• To remove \n, you can use a list comprehension:

lines = [line.strip() for line in f.readlines()]

“The readlines() method reads all lines of a file and returns them as a list of strings, including newline characters.”

Explanation:

• The readlines() method reads all lines from the file and returns them as a list of strings.
• Each string in the list includes the newline character (\n) at the end, except possibly the last line if the file does not end with a newline.
• In this example:
  • Line 1 → 'Hello\n'
  • Line 2 → 'Python\n'
  • Line 3 → 'File Handling\n'

Output:

['Hello\n', 'Python\n', 'File Handling\n']

Key Points:

• readlines() differs from read() (which returns the entire file as a single string) and readline() (which returns one line at a time).
• The newline characters are preserved unless explicitly removed using strip() or list comprehension.

Example to remove \n:

lines = [line.strip() for line in myfile.readlines()]

“The readlines() method returns all lines of the file as a list of strings, including newline characters.”

Explanation:

• The readline() method reads one line at a time from a file.
• This is memory-efficient, especially for large files, because it does not load the entire file into memory.
• In contrast, readlines() reads all lines at once and stores them in a list, which can be memory-intensive for large files.
• read() reads the entire file as a single string, which also consumes more memory.
• write() is used to write data to a file, not for reading.

Example of reading large file line by line:

with open("largefile.txt", "r") as f:
    while True:
        line = f.readline()
        if line == '':
            break
        print(line, end='')

• Each iteration reads only one line.
• The loop stops when readline() returns an empty string '', indicating the end of the file.

Key Points:

• readline() is ideal for processing files line by line.
• It helps avoid memory overflow when dealing with large files.

“The readline() method reads a single line at a time, making it suitable for large files where memory usage is a concern.”

Explanation:

• The readline(n) method reads at most n characters from the current line in a file.
• Reading stops earlier if a newline character (\n) is encountered before reaching n characters.
• It does not read multiple lines; only the current line is affected.
• If n is omitted, readline() reads the entire line.

Example:

f = open("demo.txt", "r")
line = f.readline(5)
print(line)
f.close()

If demo.txt contains:

Hello World

• readline(5) outputs:

Hello

• Only the first 5 characters of the first line are read.

Key Points:

• readline(n) is different from readlines(), which reads all lines into a list.
• Useful when you want partial reading of a line, e.g., for parsing large files line by line.

“The readline(n) method reads at most n characters from the current line, stopping at the newline character if encountered before n characters.”

Explanation:

• The readlines() method reads all lines from the current file pointer position and returns them as a list of strings.
• If the file is empty, there are no lines to read.
• In this case, readlines() returns an empty list [], indicating the file contains no content.
• It does not return None and does not raise any error.

Example:

f = open("empty.txt", "r")
lines = f.readlines()
print(lines)
f.close()

Output:

[ ]

Key Points:

• An empty file always results in an empty list when using readlines().
• This behavior is useful for checking whether a file has any content before processing.

“If the file has no lines, the readlines() method returns an empty list [].”

Explanation:

readline() Python ka ek file object method hai jo file se ek line ko string ke roop me read karta hai.

• Ye method newline character (\n) tak line read karta hai aur us line ko string me return karta hai.
• Agar file ka end (EOF) aajaye, to readline() empty string ("") return karta hai, jo batata hai ki file me aur content nahi hai.
• readline() ek string return karta hai, list nahi. Agar aapko file ki saari lines ek list me chahiye, to readlines() method use hota hai.

Example:

f = open("example.txt", "r")
print(f.readline())  # Output: 'Hello\n'
print(f.readline())  # Output: 'World\n'
print(f.readline())  # Output: 'Python\n'
print(f.readline())  # Output: ''  (empty string at EOF)

"f.readline() reads one entire line from the file. A trailing newline character is kept in the string. Returns an empty string when EOF is reached."

Explanation:

The readlines() method reads all lines from a file and stores them in a list of strings, where each element corresponds to one line, often including the newline character (\n).

After reading the lines, the split() method can be applied to each line. split() divides a string into words based on whitespace and returns them as a list. This allows each word in a line to be accessed individually as elements of a list.

Example:

f = open("example.txt", "r")
lines = f.readlines()  # ['Hello world\n', 'Python programming\n']

for line in lines:
    words = line.split()
    print(words)

Output:

['Hello', 'world']
['Python', 'programming']

Here, split() converts each line into a list of words, which is a common practice for processing text data word by word.

"The split() method returns a list of the words in the string, using whitespace as the default separator."

Explanation:

In Python, file objects are iterable, which means you can loop over them directly using a for loop. Each iteration of the loop returns the next line in the file as a string, including the newline character (\n). This method is memory-efficient because it reads one line at a time rather than loading the entire file into memory (unlike readlines()).

Example:

f = open("example.txt", "r")

for line in f:
    print(line, end='')  # Prints each line of the file

• Here, for line in f: automatically reads the file line by line.
• It avoids the need to use readline() or readlines() explicitly.
• This approach is particularly useful for large files, where reading all lines at once may be memory-intensive.

"File objects are iterable, so you can loop over the file object to read lines one by one."

Explanation:

• The splitlines() method splits a string into a list of lines without including the newline character (\n) at the end of each line.
• This makes it different from readline() or readlines(), which preserve the newline character in the returned string(s).
• Similarly, iterating over a file using for line in file: also preserves the newline character.

Example:

f = open("example.txt", "r")
content = f.read()
lines = content.splitlines()
print(lines)

• If example.txt contains:

Hello
World
Python

• The output will be:

['Hello', 'World', 'Python']

• Notice that the newline characters (\n) are removed by splitlines().

"Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends=True."

Explanation:

• The split() method in Python is used on strings to divide them into a list of substrings.
• When called without any arguments, split() uses whitespace (space, tab, newline) as the default delimiter.
• This is commonly applied to a line read from a file (using readline() or iterating over the file) to break the line into individual words for further processing.

Example:

line = "Python programming is fun\n"
words = line.split()
print(words)

Output:

['Python', 'programming', 'is', 'fun']

• Here, split() ignores the newline character (\n) and splits the line into words.

"The split() method returns a list of the words in the string, using whitespace as the default separator."

Explanation:

• In the first iteration, line will contain the first line of the file or list d:

"Hello everyone"

• Applying split() on this line divides the string at whitespace by default.
• Therefore, "Hello everyone".split() results in a list of words:

['Hello', 'everyone']

• This list is then printed by print(words).

Example Demonstration:

d = ["Hello everyone", "Writing multiline strings", "This is the third line"]

for line in d:
    words = line.split()
    print(words)

Output of first iteration:

['Hello', 'everyone']

• split() does not split into characters (like option D) and keeps each word as a separate element in the list.

"The split() method returns a list of the words in the string, using whitespace as the default separator."

Explanation:

• split() method:
  • Operates on a string and splits it into a list of words based on whitespace (by default) or a specified delimiter.
  • Example:

line = "Hello world"
words = line.split()
print(words)

Output:

['Hello', 'world']

• splitlines() method:
  • Operates on a string and splits it into lines, returning a list of strings, without the newline character (\n).
  • Example:

text = "Hello world\nPython programming\n"
lines = text.splitlines()
print(lines)

Output:

['Hello world', 'Python programming']

• Key difference:
  • split() → splits a line into words.
  • splitlines() → splits a multi-line string into lines.

"split() divides a string into words using a delimiter; splitlines() divides a string into lines and removes the newline characters."

Explanation:

• The splitlines() method splits a string at line boundaries (like \n, \r\n) and returns a list of strings.
• Importantly, it removes the newline characters (\n) from the resulting list.
• Here, "Hello everyone\n" contains only one line, so splitlines() returns a list with that single line as an element, without the \n.

Example:

line = "Hello everyone\n"
result = line.splitlines()
print(result)

Output:

['Hello everyone']

• It does not split words; that’s what split() does.
• The newline character is removed in the resulting list.

"Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends=True."

Explanation:

• In Python, file modes determine how a file is opened.
• The mode 'w' stands for write mode:
  • If the file already exists, opening it in 'w' mode overwrites the existing content.
  • If the file does not exist, a new file is created.
• This mode is used in Program 2-1 to write user input into a text file, replacing any existing content if the file already exists.

Example:

f = open("example.txt", "w")
f.write("Hello World\n")
f.close()

• After execution, example.txt will contain:

Hello World

"Mode 'w' opens a file for writing. If the file exists, it is truncated. If it does not exist, it is created."

Explanation:

• In Program 2-1, the file is opened in write mode ('w').
• Write mode ('w') behavior:
  • If the file already exists, opening it in 'w' truncates the file, i.e., all existing content is erased.
  • If the file does not exist, a new file is created.
• Therefore, if testfile.txt exists, all its previous content will be overwritten with the new input provided by the user.

Example:

# Existing file content: "Old Data"
f = open("testfile.txt", "w")
f.write("New Data")
f.close()

• After execution, testfile.txt will contain:

New Data

• The previous content "Old Data" is lost.

"Mode 'w' opens a file for writing. If the file exists, it is truncated. If it does not exist, it is created."

Explanation:

• In Python, the write() method is used to write a string to a file at the current file pointer position.
• When the file is opened in write mode ('w'), write() can store user input into the file.
• Unlike read() or readlines(), which read data from a file, write() is specifically for outputting text to a file.

Example:

f = open("testfile.txt", "w")
f.write("Hello World\n")
f.close()

• After execution, testfile.txt will contain:

Hello World

• The string is written exactly as provided, at the beginning of the file if 'w' mode is used.

"write(string) writes the contents of string to the file. Returns the number of characters written."

Explanation:

• In Python, file objects are iterable, which allows you to loop directly over the file using a for loop.
• Each iteration of the loop reads the next line from the file, including the newline character (\n).
• This method is memory-efficient because it reads one line at a time, instead of loading the entire file into memory (as read() or readlines() would do).
• In Program 2-1, after writing user input to the file, the file is reopened in read mode, and a loop like for line in f: is used to display the contents line by line.

Example:

f = open("testfile.txt", "r")
for line in f:
    print(line, end='')  # Prints each line from the file
f.close()

• Each iteration of for line in f: gives one line as a string, which can then be processed or displayed.

"File objects are iterable, so you can loop over the file object to read lines one by one efficiently."

Explanation:

• The close() method is used to close a file object after all file operations are complete.
• When writing to a file, Python buffers the data in memory for efficiency.
• fobject.close() ensures that:
  1. All buffered data is written to the file.
  2. System resources associated with the file are released.
• Failing to close a file may result in data not being saved properly or resources remaining allocated unnecessarily.

Example:

f = open("testfile.txt", "w")
f.write("Hello World\n")
f.close()  # Ensures data is flushed and file is properly closed

• After close(), the file is safely written and no longer locked by the program.

"close() flushes the write buffer of the file and releases system resources associated with it."

Explanation:

• In Python, writing to a file is buffered, meaning data is temporarily stored in memory before being written to disk.
• If close() is not called, the buffered data may not be completely written to the file.
• Calling close() ensures that:
  1. All buffered data is flushed to the disk.
  2. The file is properly closed, and system resources are released.
• Failing to close the file may result in partial or lost data, especially when writing large amounts of data.

Example:

f = open("testfile.txt", "w")
f.write("Hello World\n")
# f.close() is missing

• Without close(), the text "Hello World\n" might not be fully saved to testfile.txt.
• Using with open(...) as f: is a better practice as it automatically closes the file.

"Buffered output may not be written to disk until the file is closed. close() flushes the buffer and releases system resources."

Explanation:

• Program 2-1 Flow:
  1. Write user input: The program opens the file in write mode ('w') and writes the input provided by the user.
  2. Close file: The file is closed using close() to flush the buffer and release system resources.
  3. Open for reading: The file is reopened in read mode ('r') to access its contents.
  4. Iterate lines: The program uses a for loop over the file object to read and display lines one by one efficiently.
• This ensures data integrity, as writing is completed and resources are released before reading begins.

Example Flow:

# Write user input
f = open("testfile.txt", "w")
f.write("Hello World\n")
f.close()

# Read file
f = open("testfile.txt", "r")
for line in f:
    print(line, end='')
f.close()

Output:

Hello World

• The program follows the sequence described in option B.

"To write and read from a file safely, open in write mode, close the file, then reopen in read mode to access the content."

Explanation:

• The open() function in Python is used to open a file and returns a file object.
• A file object represents the connection between the program and the file, and it provides methods to read from or write to the file.
• The file object can be used with methods such as:
  • read() – to read file content
  • write() – to write to the file
  • readline() / readlines() – to read lines
  • close() – to close the file

Example:

f = open("testfile.txt", "r")
print(type(f))
f.close()

Output:

<class '_io.TextIOWrapper'>

• This shows that open() returns a file object (in Python, typically _io.TextIOWrapper for text files).

"open() returns a file object, which provides methods and attributes to interact with the file."

Explanation:

• In Python, file objects are iterable, which allows a for loop to iterate line by line.
• Each iteration returns one line as a string, including the newline character (\n) at the end.
• This method is memory-efficient, as it does not load the entire file into memory like readlines().

Example:

f = open("testfile.txt", "r")
for line in f:
    print(line, end='')
f.close()

• If testfile.txt contains:

Hello World
Python Programming

• Output:

Hello World
Python Programming

• Each iteration of for line in f: gives one line at a time, which can then be processed or printed.

"File objects are iterable. Iterating over a file object returns one line at a time."

Explanation:

In Python, the input() function reads user input as a string.
If the user simply presses Enter without typing anything, input() returns an empty string ("").

Consider this part of Program 2-1 (from NCERT):

myfile = open("poem.txt", "w")
line = input("Enter text: ")
myfile.write(line)
myfile.close()

If the user presses Enter without typing anything,

• line becomes an empty string ("").
• When myfile.write(line) executes, it writes exactly what is passed — in this case, an empty string.

If the user pressed Enter (which includes a newline), the file will show a blank line (i.e., just a \n).

Hence, the file poem.txt will contain a blank line, not an error or default value.

Concept Recap:

• write() writes exactly the given string — even if it’s empty.
• No error occurs when writing an empty string.
• File creation depends only on the open() function, not on the content written.

“Write the given string to the stream. Returns the number of characters written.”

Explanation:

When a line is read from a file using readline() or by iterating over the file object, it is received as a string.
To separate and display each word from that line, we use the split() method.

For example:

line = "Python is fun"
words = line.split()
print(words)

Output:

['Python', 'is', 'fun']

The split() method divides a string at whitespace (space, tab, or newline) and returns a list of individual words. You can also specify a custom delimiter like split(',') if the words are separated by commas.

In contrast, other methods such as splitlines() divide text by lines, not by words; readlines() reads multiple lines from a file as list elements; and write() is used to write data into a file, not to process or display it.

Hence, only split() correctly separates words from a single line read from a file.

“Return a list of the words in the string, using sep as the delimiter string.”

Explanation:

In Python, every file object maintains a file pointer that indicates the current position (in bytes) within the file.
The tell() method returns an integer value that represents the number of bytes from the beginning of the file up to the current position of this pointer.

For example:

f = open("data.txt", "r")
pos = f.tell()
print(pos)

If the file pointer is at the start of the file, tell() will return 0.
After reading or writing some data, the file pointer moves forward, and calling tell() again will return a larger value corresponding to that byte position.

Thus, tell() helps track where the next read or write operation will occur.

It does not return the number of lines, file name, or total size of the file — only the current byte offset.

Explanation:

The seek(offset, reference_point) method in Python is used to move the file pointer (also called the file cursor) to a new position, allowing random access within a file.

Its syntax is:

file_object.seek(offset, reference_point)

• offset → number of bytes to move the pointer.
• reference_point → starting position from where movement is measured:
  • 0 → beginning of the file (default)
  • 1 → current position
  • 2 → end of the file

For example:

f = open("data.txt", "rb")
f.seek(10, 0)     # moves pointer 10 bytes from start
position = f.tell()
print(position)

This will display 10, meaning the file pointer is now 10 bytes from the beginning.

Hence, seek() does not write or delete data, nor does it move by line numbers — it moves by byte positions, based on the given reference point.

Explanation:

The seek() method in Python moves the file pointer (cursor) to a specific position in the file.
Its general syntax is:

file_object.seek(offset, reference_point)

Here,

• offset → number of bytes to move, and
• reference_point → the position from which the movement is calculated.

If you don’t specify the reference_point, Python automatically assumes it to be 0, which represents the beginning of the file.
This means that seek(offset) is equivalent to seek(offset, 0).

For example:

f = open("example.txt", "rb")
f.seek(5)   # same as f.seek(5, 0)
print(f.tell())

This moves the file pointer 5 bytes from the start of the file.

As per the Python official documentation,

“The whence argument defaults to 0, which means absolute file positioning (from the start of the file).”

Hence, seek() by default counts the byte offset from the beginning of the file unless another reference point is provided

Explanation:

In Python, the seek(offset, reference_point) method repositions the file pointer within a file.
Here:

• offset specifies how many bytes to move, and
• reference_point (also called whence) specifies from where the movement starts.

In the statement:

fileObject.seek(5, 0)

• The 5 is the offset, meaning the pointer should move 5 bytes ahead.
• The 0 (reference point) represents the beginning of the file.

So this command moves the file pointer 5 bytes from the start of the file.
After executing it, calling fileObject.tell() will return 5, showing the pointer’s new position.

It does not move by lines, nor from the current or end positions—movement is always in bytes.

As per the Python official documentation,

“The whence argument defaults to 0, which means absolute file positioning (from the start of the file).”

Hence, in seek(5, 0), the number 5 signifies the byte offset from the file’s beginning.

Explanation:

In Python’s file handling, the seek(offset, reference_point) method allows you to move the file pointer to a specific position within a file.
Here, the reference_point (also called whence) determines from where the movement begins:

Reference Point	Value	Meaning
0	Beginning of file	Absolute positioning
1	Current position	Relative positioning
2	End of file	Relative to file end

When we write:

fileObject.seek(offset, 1)

the file pointer moves offset bytes forward or backward (if negative) from its current position.

Example:

f = open("data.txt", "rb")
f.seek(10, 0)   # move to byte 10 from start
f.seek(5, 1)    # move 5 bytes ahead from current position (byte 15)
print(f.tell()) # Output: 15

Thus, when the reference_point is 1, seek() performs movement relative to the current file position, enabling precise navigation inside the file.

As per the Python official documentation,

“The whence argument can be 0 (absolute file positioning), 1 (seek relative to the current position), or 2 (seek relative to the file’s end).”

Explanation:

In Python’s file handling, the seek(offset, reference_point) method repositions the file pointer within a file. The reference_point (also called whence) specifies from where the offset is measured:

Reference Point	Value	Meaning
0	Beginning of file	Absolute positioning
1	Current position	Relative to current pointer
2	End of file	Relative to the end of the file

When we use:

fileObject.seek(offset, 2)

the file pointer moves offset bytes relative to the end of the file.

• If the offset is 0, the pointer is positioned at EOF (End of File).
• If the offset is negative, the pointer moves backward from the end.
• Positive offsets (beyond EOF) are technically allowed but rarely used because they point past the file’s actual end.

Example:

f = open("data.txt", "rb")
f.seek(0, 2)   # move pointer to the end of file
position = f.tell()
print(position)

This will display the total number of bytes in the file, as the pointer is now at its end.

As per the Python official documentation,

“The whence argument can be 0 (absolute positioning), 1 (relative to current position), or 2 (relative to the file’s end).”

Thus, when reference_point is 2, movement occurs relative to the end of the file.

Explanation:

The seek() method is used to reposition the file pointer to a specific location within a file.
However, its behavior is not identical for text files and binary files.

In binary files (opened with mode 'rb' or 'wb'), data is handled as raw bytes, so every movement with seek(offset, reference_point) corresponds exactly to that number of bytes.
Example:

f = open("data.bin", "rb")
f.seek(10, 0)   # moves pointer to 10th byte

Here, movement is precise and reliable because no encoding or newline conversion is involved.

In text files (opened with mode 'r' or 'w'), data is processed through encodings (like UTF-8) and newline conversions (\n ↔ \r\n on Windows).
These conversions make byte-level positioning inaccurate — meaning seek() might not move exactly where you expect, especially when using offsets other than zero.

Therefore, seek() works reliably and accurately only in binary mode, while in text mode it can behave differently depending on the system’s encoding and newline conventions.

As per the Python official documentation,

“In text files, only offsets returned by tell() are legal arguments to seek(). The whence value should be 0.”

Hence, seek() does not work exactly the same way in text and binary files.

Explanation:

• When a file is opened, the file pointer is positioned at the beginning of the file.
  Hence, f.tell() returns 0 initially.
• The read(5) method reads the first 5 characters of the file ("Hello").
• After reading, the pointer moves 5 positions forward.
  Therefore, the second f.tell() returns 5.

So the program prints:

0
5

This shows how the tell() method tracks the current position of the file pointer, and how reading changes it accordingly.

Explanation:

Normally, when we read a file using read() or readline(), data is accessed sequentially — from start to end in order.
However, sometimes we need to jump to a specific part of the file to read or modify data. This is called random access.

The seek(offset, reference_point) method is used for this purpose.
It moves the file pointer to any desired position in the file, enabling reading or writing from that point onward.

“The seek() function is used to reposition the file pointer for random file access.” 
“Change the stream position to the given byte offset.” 

For example:

f = open("data.txt", "rb")
f.seek(10)      # Moves pointer to 10th byte
print(f.read(5))  # Reads 5 bytes from there
f.close()

Thus, seek() allows non-sequential (random) access, while methods like read() or readline() only read sequentially.

Explanation:

The seek(offset, reference_point) method repositions the file pointer to a specific byte location in the file.
Here, the offset is 0 and the reference_point (also called whence) is 2.

In Python:

• 0 → Beginning of file
• 1 → Current position
• 2 → End of file

So, seek(0, 2) moves the file pointer to the end of the file, because it sets the pointer 0 bytes away from the end.
This is often used when you want to append data or check the total size of a file using tell().

“The seek() function is used to reposition the file pointer for random file access.” 
“Change the stream position to the given byte offset.” 

Example:

f = open("data.txt", "rb")
f.seek(0, 2)      # Moves pointer to end of file
print(f.tell())   # Shows total number of bytes
f.close()

Thus, executing seek(0,2) places the file pointer exactly at the end of the file, without moving it forward or backward.

Explanation:

In Python file handling, the tell() method is used to find the current position of the file pointer — i.e., how many bytes have been read or written from the beginning of the file.
It returns an integer value representing the byte offset of the file pointer.

This information helps the program determine where the next read or write operation will take place.
tell() is especially useful when working with large files or when combined with seek() for random access.

“The tell() method returns the current position of the file pointer in terms of bytes from the beginning of the file.” 
“Return the current stream position.” 

Example:

f = open("example.txt", "r")
print(f.tell())   # 0 at the beginning
f.read(10)
print(f.tell())   # 10 after reading 10 bytes
f.close()

Thus, tell() allows the programmer to track the exact position of the file pointer during file operations.

Explanation:

The seek(offset, reference_point) function is used to reposition the file pointer.
Here,

• offset = -3 (negative value) → moves the pointer backward by 3 bytes
• reference_point = 1 → represents current position

So, seek(-3, 1) moves the file pointer 3 bytes backward from its current position.
This is useful for re-reading or rewriting data without reopening the file.

However, note that negative offsets are not allowed in text mode, because of character encoding differences.
They work properly only in binary mode (‘rb’ or ‘rb+’).

“The seek() function is used to reposition the file pointer for random file access.” 
“Change the stream position to the given byte offset.” 

f = open("data.txt", "rb")
f.read(10)       # pointer moves to byte 10
f.seek(-3, 1)    # moves back to byte 7
print(f.tell())  # shows 7
f.close()

Thus, executing seek(-3, 1) repositions the pointer 3 bytes backward from the current location, when used in binary mode.

Explanation:

In binary files, data is often stored as records or fixed-size blocks.
Reading such files sequentially means starting from the beginning and moving step by step until the desired data is reached — which can be slow and inefficient, especially for large files.

The seek() method allows direct or random access to any specific byte or record in the file without reading all preceding data.
This makes seek() much faster and more efficient than sequential reading when only a particular section of the file is needed.

“The seek() function is used to reposition the file pointer for random file access.” 
“Change the stream position to the given byte offset.” 

Example:

f = open("records.dat", "rb")
f.seek(200)      # Move pointer directly to byte 200
record = f.read(50)   # Read only the desired record
f.close()

Thus, seek() is preferred for binary files because it allows faster and targeted data access without processing the entire file sequentially.

Mohan Exam

Explanation:

The two most important file-pointer-related methods in Python are seek() and tell(), and they serve complementary purposes:

• seek(offset, reference_point) → moves the file pointer to a specific location (used for random access).
• tell() → returns the current position of the file pointer (used to know where reading/writing will occur next).

Together, they help in controlling and tracking file reading/writing operations efficiently — especially in binary files or large text files.

“The seek() function is used to reposition the file pointer for random file access.” 
“The tell() method returns the current position of the file pointer in terms of bytes from the beginning of the file.” 
“Change the stream position to the given byte offset.” 
“Return the current stream position.” 

Example:

f = open("demo.txt", "rb")
f.seek(10)         # Moves file pointer to byte 10
print(f.tell())    # Prints: 10
f.close()

Thus,

• seek() → controls where the file pointer goes
• tell() → informs where the file pointer currently is

They are often used together for precise file handling operations.

Explanation:

In text files, data is stored using character encoding such as UTF-8, UTF-16, etc.
These encodings may use multiple bytes to represent a single character (for example, some Unicode characters use 2 or 3 bytes).

The seek() method, however, always moves the file pointer by bytes, not by characters.
As a result, when you use seek() in text mode, the byte positions may not align with character positions, leading to inaccurate pointer placement or even decoding errors.

That’s why seek() works more predictably in binary mode ('rb' or 'rb+'), where data is handled as raw bytes rather than encoded characters.

“The seek() function is used to reposition the file pointer for random file access.” 
“In text files, using seek() may not give exact results because of variable-length encodings.” 
“In text files (those opened without a ‘b’), only offsets returned by tell() are legal arguments to seek().” 

Example:

f = open("sample.txt", "r", encoding="utf-8")
f.seek(5)       # Moves 5 bytes ahead (may be mid-character in UTF-8)
print(f.readline())
f.close()

In the above case, the pointer might land in the middle of a multi-byte character, causing decoding issues or incorrect reading.

Thus, seek() in text files has the limitation that byte offsets may not accurately represent character positions, making it unreliable for random access.

Explanation:

In Python, the open() function is used to open a file and returns a file object.
The second argument of the open() function specifies the mode — that is, how the file should be opened (read, write, append, etc.).

The mode "r+" means:

• Open the file for both reading and writing.
• The file must already exist — if it does not, Python raises a FileNotFoundError.
• The file pointer is placed at the beginning of the file.
• Existing content can be read, overwritten, or modified.

“The open() function is used to open a file in different modes like read, write, and append.” 
“Mode ‘r+’ opens the file for both reading and writing. The file pointer is placed at the beginning of the file.” 
“Open file and return a corresponding file object. The mode ‘r+’ opens the file for both reading and writing.” 

Example:

f = open("testfile.txt", "r+")
content = f.read(5)     # Reads first 5 characters
f.write("New")          # Overwrites next characters
f.close()

Thus, "r+" mode is used when you want to read and modify an existing file without creating a new one.

Explanation:

The tell() method in Python’s file handling returns the current position of the file pointer (also called the file cursor).

When a file is opened (using open()), the file pointer is automatically positioned at the beginning of the file.
Therefore, before any read or write operation, the pointer position is 0 — the first byte of the file.

So,

fileobject.tell()

initially returns 0 because the file pointer hasn’t moved yet.

Example:

f = open("sample.txt", "r")
print(f.tell())   # Output → 0
data = f.read(5)
print(f.tell())   # Output → 5 (moved 5 bytes forward)
f.close()

• The first tell() returns 0 (file pointer at start).
• The second tell() returns 5, showing the pointer moved 5 characters ahead after reading.

Concept Summary:

Method	Purpose	Initial Value
tell()	Returns current file pointer position (in bytes)	0 at file start
seek(offset)	Moves the file pointer to a specific position	Can be used with tell()

“The tell() function gives the current position of the file pointer.”

“Initially, when a file is opened, the file pointer is at the beginning (position 0).”

tell() returns an integer giving the file object’s current position in the stream.

Explanation:

The seek() method is used to reposition the file pointer within a file.
It takes two parameters:

seek(offset, reference_point)

• offset → number of bytes to move
• reference_point → starting position (default is 0, i.e., beginning of file)

So,

fileobject.seek(0)

is equivalent to

fileobject.seek(0, 0)

This command moves the file pointer to the 0th byte from the beginning of the file, meaning it resets the file pointer back to the start.

Example:

f = open("example.txt", "r")
f.read(10)          # Move pointer 10 bytes forward
print(f.tell())     # Output: 10
f.seek(0)           # Move pointer back to beginning
print(f.tell())     # Output: 0
f.close()

🔹 After reading 10 bytes, pointer is at position 10.
🔹 After seek(0), pointer goes back to the beginning (0th byte).

Concept Summary:

Method	Action	Description
seek(offset)	Moves pointer	Moves pointer to given byte position
seek(0)	Reset pointer	Moves pointer to start of file
tell()	Returns pointer	Shows current byte position

“The seek() function is used to reposition the file pointer for random file access.” 
“seek(0) sets the file pointer at the beginning of the file.” 
seek(offset, whence=0) changes the stream position to the given byte offset.

Explanation:

The seek() method repositions the file pointer to a specific byte location within the file.
When you execute

fileobject.seek(10)

it moves the file pointer to the 10th byte from the beginning of the file (since the default reference point is 0, i.e., the start of the file).

After this, when you call

fileobject.read()

it reads from the current pointer position (10th byte) up to the end of the file (EOF).

Thus, it skips the first 10 bytes and returns the remaining content from that position onward.

Example:

f = open("sample.txt", "r")
f.seek(10)         # Move pointer to 10th byte
data = f.read()    # Read from 10th byte to EOF
print(data)
f.close()

🔹 If sample.txt contains "Hello Python Programming",
then f.read() will return “n Programming” after moving to the 10th byte.

Concept Summary:

Function	Purpose	Behavior
seek(offset)	Move pointer	Moves pointer to specified byte (default from start)
read()	Read content	Reads from current pointer to end of file
tell()	Get pointer	Returns current pointer position

“The seek() function repositions the file pointer. After seek(), reading begins from the new position.”