Python Working with Files Exercises

Which of the following modes opens a file for both reading and writing, without truncating the existing content?

'w+'

'a+'

'r+'

'x+'

The mode 'r+' opens a file for both reading and writing without deleting existing data.
However, the file must already exist; otherwise, it raises a FileNotFoundError.

'w+' also allows read/write but truncates the file (deletes previous content).
'a+' allows reading and appending but the file pointer starts at the end.
'x+' creates a new file for read/write, and fails if the file already exists.

What will be the content of the file `data.txt` after executing the following code?

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

Hello Solviyo

Hello
Solviyo

Hello\nSolviyo

HelloSolviyo

# Code that writes to file
with open("data.txt", "w") as f:
    f.write("Hello\n")
    f.write("Solviyo")

# After running, the file data.txt contains two lines:
# Line 1: Hello
# Line 2: Solviyo

Writing text to a file with newlines

Option 1 – Incorrect: This shows "Hello" and "Solviyo" on the same line separated by a space; the code writes a newline after "Hello", so they are on separate lines.
Option 2 – Correct: The first write() call writes "Hello\n" (which adds a newline), and the second writes "Solviyo" on the next line → the file contains two lines: Hello and Solviyo.
Option 3 – Incorrect: This shows the literal characters \n inside the file; in reality \n is a newline character, not two characters backslash+n.
Option 4 – Incorrect: This would be true only if no newline or separator was written between the two writes (e.g., f.write("Hello") then f.write("Solviyo")), but here a newline is present.

Step-by-step reasoning:

open("data.txt", "w") opens (or creates) the file in write mode and truncates existing content.
with ensures the file is closed automatically when the block ends.
f.write("Hello\n") writes the string "Hello" followed by a newline character, so the file now contains the first line Hello and the file pointer is at the start of the second line.
f.write("Solviyo") writes "Solviyo" starting at the second line; no extra newline is added after this call.
Final file content (two lines):
Line 1: Hello
Line 2: Solviyo

Key takeaways:

Use newline characters (\n) to control line breaks when writing text files.
The with open(...) context manager automatically closes the file—preferred practice.
Opening a file with "w" truncates existing content; use "a" to append instead.

You have a text file named `info.txt` containing the following lines:

Python
Solviyo
Exercises

What will be printed after executing the following code?

with open("info.txt", "r") as f:
    content = f.readline()
    print(content.strip())

Python

Solviyo

Python Solviyo Exercises

['Python', 'Solviyo', 'Exercises']

# Code to read first line from a file
with open("info.txt", "r") as f:
    content = f.readline()
    print(content.strip())

# Output:
# Python

Reading the first line from a text file

Option 1 – Correct: The readline() method reads only the first line from the file, which is "Python". The strip() method removes the newline character at the end.
Option 2 – Incorrect: "Solviyo" is the second line of the file, not the first.
Option 3 – Incorrect: readline() reads only one line; to read all lines, read() or readlines() should be used.
Option 4 – Incorrect: The code prints a string, not a list. The readlines() method would return a list, but readline() does not.

Step-by-step reasoning:

The file info.txt contains three lines.
open("info.txt", "r") opens the file in read mode.
readline() reads the first line only: "Python\n".
strip() removes the trailing newline character \n.
print() outputs the clean text Python.

Key takeaways:

readline() reads one line at a time, making it memory-efficient for large files.
strip() is useful to remove newline and extra whitespace characters.
Always use with open(...) to automatically close the file after reading.

Which of the following statements about using `with open()` for file operations is correct?

The file must be manually closed using f.close().

with open() only works for reading files.

The file pointer always starts at the end of the file.

with open() automatically closes the file after the block ends.

Using with open() for file handling

Option 1 – Incorrect: When using with open(), Python automatically closes the file; you do not need to call f.close() manually.
Option 2 – Incorrect: with open() works for all modes – reading, writing, appending, etc.
Option 3 – Incorrect: The file pointer starts at the beginning for read/write modes, except when using append mode 'a'.
Option 4 – Correct: with open() ensures that the file is properly closed after the block ends, even if exceptions occur.

Key takeaways:

Always prefer with open(...) over manually opening and closing files.
Automatic closing helps avoid resource leaks and ensures file integrity.
This technique works with any file mode: 'r', 'w', 'a', etc.

You want to add a new line at the end of `log.txt` without overwriting the existing content. Which mode should you use?

'r'

'w'

'r+'

'a'

Appending text to an existing file

Option 1 – Incorrect: 'r' opens the file in read-only mode. You cannot write or append.
Option 2 – Incorrect: 'w' opens the file in write mode and truncates (erases) the existing content.
Option 3 – Incorrect: 'r+' allows reading and writing but starts at the beginning; existing content may be overwritten if not handled carefully.
Option 4 – Correct: 'a' mode opens the file for appending. New data is written **at the end** of the file without affecting existing content.

Step-by-step reasoning:

Open the file in append mode: with open("log.txt", "a") as f.
Write the new line: f.write("New log entry\n").
Python automatically places the file pointer at the end, ensuring existing content remains intact.
After the block ends, the file is automatically closed.

Key takeaways:

Use 'a' mode whenever you need to add data without losing previous content.
with open(...) ensures safe and clean file closure.
Appending is commonly used for logs, audit trails, and incremental data storage.

Which of the following snippets correctly reads the content of `example.txt` and prints each line in uppercase, ensuring the file is safely closed afterward?

f = open("example.txt", "r")
for line in f:
    print(line.upper())
f.close()

with open("example.txt", "r") as f:
    print(f.read().upper())

with open("example.txt", "r") as f:
    for line in f:
        print(line.upper())

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

Reading a file line by line with safe file handling

Option 1 – Incorrect: Manually opens and closes the file. Although it works, it is not safe if an exception occurs before f.close() is called.
Option 2 – Incorrect: f.read() reads the entire content as a single string; upper() converts everything at once, but iterating line by line is preferred for large files.
Option 3 – Correct: Uses with open(...) to ensure the file is automatically closed. Iterates over each line, printing it in uppercase individually.
Option 4 – Incorrect: readlines() returns a list of lines; calling upper() directly on a list raises an error.

Step-by-step reasoning:

with open("example.txt", "r") as f safely opens the file for reading.
Iterating over f retrieves one line at a time, efficient for memory.
line.upper() converts the line to uppercase before printing.
After the block ends, Python automatically closes the file.

Key takeaways:

Always prefer with open(...) to ensure files are properly closed.
Iterating line by line is more memory-efficient than read() for large files.
Be careful with methods like upper() on lists vs strings.

You want to read all lines from `data.txt` and remove the trailing newline characters from each line. Which snippet achieves this correctly?

with open("data.txt", "r") as f:
    lines = [line.strip() for line in f.readlines()]
print(lines)

with open("data.txt", "r") as f:
    lines = f.read()
lines = [line.strip() for line in lines]
print(lines)

f = open("data.txt", "r")
lines = [line.strip() for line in f]
f.close()
print(lines)

with open("data.txt", "r") as f:
    lines = f.readlines().upper()
print(lines)

Reading all lines from a file and stripping newlines

Option 1 – Correct: f.readlines() reads all lines as a list. Using a list comprehension with strip() removes trailing newline characters for each line.
Option 2 – Incorrect: f.read() returns a single string, so iterating over it splits it into individual characters, not lines.
Option 3 – Incorrect: Although iterating directly over f works, the file is opened without with context manager; if an exception occurs, the file may not be properly closed.
Option 4 – Incorrect: readlines() returns a list of strings, and lists do not have an upper() method; this would raise an error.

Step-by-step reasoning:

with open("data.txt", "r") as f safely opens the file for reading.
f.readlines() returns a list of all lines, each ending with a newline character.
List comprehension: [line.strip() for line in f.readlines()] removes trailing newlines.
Printing lines shows the clean list of strings.

Key takeaways:

Use strip() to clean up newline characters from file lines.
List comprehensions are efficient and concise for processing file data.
Always prefer with open(...) to handle files safely.

Which of the following snippets correctly moves the file pointer to the beginning of the file before reading it again?

with open("log.txt", "r") as f:
    f.read()
    f.seek(0)
    print(f.read())

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

f = open("log.txt", "r")
f.read()
f.tell()
f.read()
f.close()

with open("log.txt", "r") as f:
    print(f.read(0))

Manipulating the file pointer using seek()

Option 1 – Correct: After reading the entire file with f.read(), the file pointer is at the end. Using f.seek(0) moves the pointer back to the beginning, allowing f.read() to read the content again.
Option 2 – Incorrect: f.seek(10) moves the pointer to the 10th byte, not the beginning. Reading from there will not include the first 10 characters.
Option 3 – Incorrect: f.tell() just returns the current pointer position; it does not move it. The second f.read() would return an empty string since the pointer is already at the end.
Option 4 – Incorrect: f.read(0) reads zero characters, so nothing is printed.

Step-by-step reasoning:

f.read() moves the file pointer to the end.
f.seek(0) resets the pointer to the start of the file.
Second f.read() reads the entire content again from the beginning.

Key takeaways:

seek(offset) moves the file pointer to the specified byte position.
Use tell() to check the current position of the file pointer.
Resetting the pointer is useful when you need to reread a file without reopening it.

You have a very large file `bigdata.txt`. Which of the following is the most memory-efficient way to read and process it line by line?

with open("bigdata.txt", "r") as f:
    lines = f.readlines()
    for line in lines:
        process(line)

with open("bigdata.txt", "r") as f:
    for line in f:
        process(line)

with open("bigdata.txt", "r") as f:
    content = f.read()
    for line in content.split("\n"):
        process(line)

f = open("bigdata.txt", "r")
lines = f.readlines()
for line in lines:
    process(line)
f.close()

Reading large files efficiently line by line

Option 1 – Incorrect: readlines() reads the entire file into memory at once, which can be memory-intensive for very large files.
Option 2 – Correct: Iterating directly over the file object reads one line at a time, keeping memory usage minimal while allowing processing of each line.
Option 3 – Incorrect: f.read() loads the whole file into memory, which defeats memory efficiency for large files.
Option 4 – Incorrect: Similar to Option 1, readlines() consumes memory for the entire file, and manually opening/closing adds risk of not closing if an exception occurs.

Step-by-step reasoning:

Opening the file with with open(...) ensures safe closure.
Iterating directly over f reads one line at a time.
process(line) can perform any required operation on each line.
Memory usage remains low, regardless of file size.

Key takeaways:

For large files, avoid read() or readlines() which load the whole file into memory.
Iterating directly over the file object is Pythonic and memory-efficient.
Always use with open(...) for safe file handling.

Which of the following is the best approach to check if a file exists before reading it, avoiding runtime errors?

Always try to open the file without checking; handle exceptions later.

Use os.remove() before opening the file.

Check file existence using if "filename.txt": before opening.

Use os.path.exists("filename.txt") before opening the file.

Checking if a file exists before opening

Option 1 – Incorrect: Opening without checking may raise FileNotFoundError. Although exceptions can be handled, pre-checking is safer in many cases.
Option 2 – Incorrect: os.remove() deletes the file; it does not check for existence.
Option 3 – Incorrect: The statement if "filename.txt": always evaluates to True because it is a non-empty string; it does not check file existence.
Option 4 – Correct: Using os.path.exists("filename.txt") safely checks if the file exists before attempting to open it.

Example Code:

import os

if os.path.exists("filename.txt"):
    with open("filename.txt", "r") as f:
        print(f.read())
else:
    print("File does not exist.")

Key takeaways:

Use os.path.exists() to check file existence before reading or writing.
Combining it with with open(...) ensures safe file handling.
Pre-checking avoids unnecessary exceptions and makes code more readable and robust.

You want to write a list of integers `[10, 20, 30, 40]` to a binary file `numbers.bin` and then read them back. Which snippet correctly does this?

numbers = [10, 20, 30, 40]
with open("numbers.bin", "wb") as f:
    for n in numbers:
        f.write(bytes(n))
with open("numbers.bin", "rb") as f:
    data = f.read()
print(list(data))

numbers = [10, 20, 30, 40]
with open("numbers.bin", "wb") as f:
    for n in numbers:
        f.write(n.to_bytes(2, byteorder='big'))
with open("numbers.bin", "rb") as f:
    data = f.read()
numbers_read = [int.from_bytes(data[i:i+2], byteorder='big') for i in range(0, len(data), 2)]
print(numbers_read)

numbers = [10, 20, 30, 40]
with open("numbers.bin", "wb") as f:
    f.write(str(numbers).encode())
with open("numbers.bin", "rb") as f:
    data = f.read()
print(data)

numbers = [10, 20, 30, 40]
with open("numbers.bin", "wb") as f:
    f.write(numbers)
with open("numbers.bin", "rb") as f:
    data = f.read()
print(data)

Writing and reading integers to/from a binary file

Option 1 – Incorrect: bytes(n) expects an iterable of integers (0–255), so bytes(10) creates 10 null bytes, not the integer value itself.
Option 2 – Correct: n.to_bytes(2, byteorder='big') converts each integer into 2 bytes. Reading back and using int.from_bytes(...) reconstructs the original integers.
Option 3 – Incorrect: Writing str(numbers).encode() stores a string representation; reading back gives a bytes object of the string, not original integers.
Option 4 – Incorrect: Directly writing a list with f.write(numbers) raises a TypeError; lists cannot be directly written as bytes.

Step-by-step reasoning:

Convert each integer to bytes: n.to_bytes(2, byteorder='big').
Write the bytes sequentially to numbers.bin.
Read all bytes from the file using f.read().
Reconstruct integers: iterate over the byte data in chunks of 2 and use int.from_bytes(...).

Key takeaways:

Binary files require data to be in bytes; direct writing of Python objects like integers or lists is not allowed.
to_bytes() and from_bytes() are essential for converting integers to and from byte representations.
This approach is memory-efficient and works well for numeric data storage and transmission.

You have a text containing Unicode characters: `"Solviyo – Python Exercises"`. Which snippet correctly writes this text to a file in UTF-16 encoding and reads it back?

text = "Solviyo – Python Exercises"
with open("exercise.txt", "w", encoding="utf-16") as f:
    f.write(text)
with open("exercise.txt", "r", encoding="utf-16") as f:
    content = f.read()
print(content)

text = "Solviyo – Python Exercises"
with open("exercise.txt", "w") as f:
    f.write(text.encode("utf-16"))
with open("exercise.txt", "r") as f:
    content = f.read()
print(content)

text = "Solviyo – Python Exercises"
with open("exercise.txt", "wb") as f:
    f.write(text.encode("utf-8"))
with open("exercise.txt", "rb") as f:
    content = f.read().decode("utf-8")
print(content)

text = "Solviyo – Python Exercises"
with open("exercise.txt", "w") as f:
    f.write(text)
with open("exercise.txt", "r") as f:
    content = f.read()
print(content)

Writing and reading text with specific encoding (UTF-16)

Option 1 – Correct: Opens the file in text mode with encoding="utf-16". Writing and reading preserve Unicode characters correctly.
Option 2 – Incorrect: f.write(text.encode("utf-16")) returns bytes, but the file is opened in text mode, which expects a string. This raises TypeError.
Option 3 – Incorrect: Uses UTF-8 encoding, not UTF-16. While it works for the text, it does not satisfy the UTF-16 requirement.
Option 4 – Incorrect: Default encoding (usually UTF-8) is used; special Unicode characters may not be preserved correctly across systems.

Step-by-step reasoning:

Open the file in text mode with encoding="utf-16" to handle Unicode correctly.
Write the string directly; Python handles encoding internally.
Read the content using the same encoding to get back the original string.

Example Code:

text = "Solviyo – Python Exercises"
with open("exercise.txt", "w", encoding="utf-16") as f:
    f.write(text)

with open("exercise.txt", "r", encoding="utf-16") as f:
    content = f.read()

print(content)  # Output: Solviyo – Python Exercises

Key takeaways:

Always specify encoding explicitly when working with Unicode to avoid cross-platform issues.
Text mode with the correct encoding handles conversion between string and bytes automatically.
UTF-16 uses 2 bytes per character, useful for some international applications.

You have a file `sample.txt` containing multiple lines. You want to read the first 10 characters, move back 5 characters, and then read the next 10 characters. Which snippet achieves this correctly?

with open("sample.txt", "r") as f:
    print(f.read(10))
    f.seek(-5, 1)
    print(f.read(10))

with open("sample.txt", "r") as f:
    print(f.read(10))
    f.seek(5)
    print(f.read(10))

f = open("sample.txt", "r")
print(f.read(10))
f.seek(-5)
print(f.read(10))
f.close()

with open("sample.txt", "r") as f:
    print(f.read(5))
    f.seek(10)
    print(f.read(10))

Using seek() with relative position to re-read part of a file

Option 1 – Correct: f.read(10) reads the first 10 characters. f.seek(-5, 1) moves the pointer 5 characters back from the current position (relative seek), so the next f.read(10) reads the correct range.
Option 2 – Incorrect: f.seek(5) moves the pointer to the 6th character from the beginning, not relative to the current pointer, so the next read skips characters.
Option 3 – Incorrect: f.seek(-5) in text mode without specifying relative position (whence=0 by default) may raise UnsupportedOperation error.
Option 4 – Incorrect: First f.read(5) reads fewer characters, and f.seek(10) moves pointer to 11th character, skipping part of the desired data.

Step-by-step reasoning:

Read first 10 characters: pointer moves from 0 → 10.
f.seek(-5, 1): move back 5 characters from current pointer → pointer at position 5.
Read next 10 characters: pointer moves 5 → 15, correctly capturing overlapping portion.

Example Code:

with open("sample.txt", "r") as f:
    first_part = f.read(10)
    f.seek(-5, 1)
    second_part = f.read(10)

print(first_part)
print(second_part)

Key takeaways:

seek(offset, whence) allows moving the file pointer relative to beginning (0), current (1), or end (2).
Negative offsets can only be used with whence=1 or whence=2 to move backwards.
Useful for re-reading or skipping portions of a file without reopening it.

You want to read a large file `bigfile.txt` in chunks of 1024 bytes to avoid memory issues. Which snippet correctly does this?

with open("bigfile.txt", "r") as f:
    while True:
        chunk = f.read(1024)
        if not chunk:
            break
        process(chunk)

with open("bigfile.txt", "r") as f:
    for chunk in f.read(1024):
        process(chunk)

f = open("bigfile.txt", "r")
chunk = f.readall(1024)
process(chunk)
f.close()

with open("bigfile.txt", "r") as f:
    process(f.read())

Reading a large file in fixed-size chunks

Option 1 – Correct: Uses a while True loop to read 1024 bytes at a time. The loop breaks when f.read(1024) returns an empty string (end of file). Each chunk is processed efficiently without loading the entire file into memory.
Option 2 – Incorrect: f.read(1024) returns a string of 1024 characters; iterating over it loops character by character, not chunk by chunk.
Option 3 – Incorrect: f.readall() does not exist in Python; also reads entire file into memory.
Option 4 – Incorrect: f.read() reads the entire file at once, which is memory-inefficient for large files.

Step-by-step reasoning:

Open the file in read mode: with open("bigfile.txt", "r") as f.
Use f.read(1024) to read up to 1024 characters (bytes in text mode) at a time.
Check if chunk is empty; if yes, break the loop.
Process each chunk individually using process(chunk).

Example Code:

def process(chunk):
    print("Processing chunk of size:", len(chunk))

with open("bigfile.txt", "r") as f:
    while True:
        chunk = f.read(1024)
        if not chunk:
            break
        process(chunk)

Key takeaways:

Reading files in chunks prevents memory overload when working with large files.
Always check for the end of the file using the returned chunk.
This technique is commonly used in file streaming, data pipelines, and network file transfer.

You want to read a file `input.txt`, convert all text to uppercase, and write it to `output.txt` in a memory-efficient way. Which snippet correctly does this?

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
    for line in fin:
        fout.write(line.upper())

with open("input.txt", "r") as fin:
    data = fin.read()
with open("output.txt", "w") as fout:
    fout.write(data.upper())

input_file = open("input.txt", "r")
output_file = open("output.txt", "w")
output_file.write(input_file.read().upper())
input_file.close()
output_file.close()

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
    fout.write(fin.read())

Reading from one file, transforming, and writing to another efficiently

Option 1 – Correct: Reads the file line by line, converts each line to uppercase using line.upper(), and writes it immediately to the output file. Memory-efficient for large files.
Option 2 – Incorrect: fin.read() reads the entire file into memory; inefficient for very large files.
Option 3 – Incorrect: Manually opening/closing files works, but not memory-efficient; also less safe if exceptions occur.
Option 4 – Incorrect: Writes the original content without transforming to uppercase.

Step-by-step reasoning:

Open both files simultaneously using with open(...) to ensure safe closure.
Iterate line by line over input.txt to avoid loading entire file into memory.
Transform each line to uppercase using line.upper().
Write transformed line immediately to output.txt.

Example Code:

with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
    for line in fin:
        fout.write(line.upper())

Key takeaways:

Process large files line by line to keep memory usage low.
Using with open(...) ensures files are closed safely even if errors occur.
Transformations can be applied on-the-fly without storing the entire file in memory.

Consider the following code that recursively reads all `.txt` files in a directory `data/` and counts the total number of lines. Which option correctly implements this?

import os

def count_lines(dir_path):
    total_lines = 0
    for entry in os.listdir(dir_path):
        path = os.path.join(dir_path, entry)
        if os.path.isdir(path):
            total_lines += count_lines(path)
        elif path.endswith(".txt"):
            with open(path, "r") as f:
                total_lines += len(f.readlines())
    return total_lines

print(count_lines("data/"))  # Reads only top-level .txt files, ignores subdirectories

def count_lines(dir_path):
    total_lines = 0
    for entry in os.listdir(dir_path):
        if entry.endswith(".txt"):
            with open(entry, "r") as f:
                total_lines += len(f.readlines())
    return total_lines

print(count_lines("data/"))  # Correctly reads all .txt files recursively and sums lines

print(count_lines("data/"))  # Reads files but overwrites total_lines instead of summing

Recursively reading all .txt files in a directory

Option 1 – Incorrect: Only reads top-level .txt files, ignores files in subdirectories.
Option 2 – Incorrect: Does not handle subdirectories; os.listdir(dir_path) returns names without path, so open(entry, "r") may fail.
Option 3 – Correct: Combines recursion and file reading. Uses os.path.isdir(path) to check directories, recurses, and sums line counts from all .txt files.
Option 4 – Incorrect: If implemented incorrectly, total_lines could be overwritten in loops instead of accumulated.

Step-by-step reasoning:

Use os.listdir(dir_path) to get all entries in the directory.
Check if entry is a directory: os.path.isdir(path). If yes, recurse.
If entry is a .txt file, open and count lines: len(f.readlines()).
Accumulate line counts into total_lines and return after processing all entries.

Example Usage:

total = count_lines("data/")
print("Total lines in all .txt files:", total)

Key takeaways:

Recursion is useful for processing nested directories.
Always join directory and entry using os.path.join() to get the full path.
Accumulate values correctly inside recursion to avoid losing counts.

You want to read the first 15 characters of `example.txt`, move 7 characters back, and then read 10 characters. Which snippet correctly achieves this?

with open("example.txt", "r") as f:
    first_part = f.read(15)
    f.seek(7)
    second_part = f.read(10)

with open("example.txt", "r") as f:
    first_part = f.read(15)
    f.seek(-7, 1)
    second_part = f.read(10)

with open("example.txt", "r") as f:
    first_part = f.read(10)
    f.seek(-5, 1)
    second_part = f.read(15)

with open("example.txt", "r") as f:
    first_part = f.read(15)
    f.seek(0)
    second_part = f.read(10)

Manipulating file pointer to re-read a portion of a file

Option 1 – Incorrect: f.seek(7) moves the pointer to 8th character from the beginning, not relative to current position, so the second read is incorrect.
Option 2 – Correct: f.read(15) reads the first 15 characters. f.seek(-7, 1) moves 7 characters back relative to the current pointer, allowing the next f.read(10) to correctly read overlapping data.
Option 3 – Incorrect: Reads different ranges; offsets do not match the desired read pattern.
Option 4 – Incorrect: f.seek(0) moves pointer to the beginning, so second read duplicates first 10 characters instead of reading the intended section.

Step-by-step reasoning:

Read first 15 characters → pointer moves 0 → 15.
f.seek(-7, 1): move back 7 characters → pointer at position 8.
Read next 10 characters → pointer moves 8 → 18.

Example Usage:

with open("example.txt", "r") as f:
    first_part = f.read(15)
    f.seek(-7, 1)
    second_part = f.read(10)

print(first_part)
print(second_part)

Key takeaways:

seek(offset, whence) allows moving the pointer relative to current position (whence=1), beginning (0), or end (2).
Negative offsets are useful to re-read overlapping sections of a file.
Always verify pointer positions to avoid reading incorrect portions.

You want to read `largefile.txt` in 2048-byte chunks and write each chunk to `output.txt`, ensuring all data is written correctly even if the last chunk is smaller. Which snippet achieves this?

with open("largefile.txt", "rb") as fin, open("output.txt", "wb") as fout:
    fout.write(fin.read())

with open("largefile.txt", "rb") as fin:
    chunk = fin.read(2048)
    with open("output.txt", "wb") as fout:
        fout.write(chunk)

with open("largefile.txt", "rb") as fin, open("output.txt", "wb") as fout:
    while True:
        chunk = fin.read(2048)
        if not chunk:
            break
        fout.write(chunk)

with open("largefile.txt", "rb") as fin, open("output.txt", "wb") as fout:
    for chunk in fin:
        fout.write(chunk)

Buffered reading and writing of a large file

Option 1 – Incorrect: Reads the entire file at once; may cause memory issues for very large files.
Option 2 – Incorrect: Reads only the first 2048 bytes; does not loop to read the full file.
Option 3 – Correct: Uses a while True loop to read the file in 2048-byte chunks, writing each chunk to the output. Loop ends when fin.read(2048) returns empty, ensuring all data is written correctly.
Option 4 – Incorrect: Iterating over fin reads line by line (text mode default), not in 2048-byte chunks, so chunk size control is lost.

Step-by-step reasoning:

Open both files in binary mode (rb and wb).
Use fin.read(2048) to read 2048-byte chunks.
Check if chunk is empty; if yes, break the loop.
Write each chunk to output.txt immediately using fout.write(chunk).

Example Code:

with open("largefile.txt", "rb") as fin, open("output.txt", "wb") as fout:
    while True:
        chunk = fin.read(2048)
        if not chunk:
            break
        fout.write(chunk)

Key takeaways:

Buffered reading/writing prevents memory overload for very large files.
Binary mode (rb/wb) ensures exact byte copying without encoding issues.
Always handle the end of file (last chunk may be smaller than buffer size).

You want to read `logs.txt` line by line and write only lines containing the word `"ERROR"` to `error_logs.txt"`. Which snippet correctly achieves this?

with open("logs.txt", "r") as fin, open("error_logs.txt", "w") as fout:
    fout.write(fin.read())

lines = open("logs.txt").readlines()
with open("error_logs.txt", "w") as fout:
    for line in lines:
        fout.write(line)

with open("logs.txt", "r") as fin:
    errors = [line for line in fin if "ERROR" in line]
with open("error_logs.txt", "w") as fout:
    fout.write("".join(errors))

with open("logs.txt", "r") as fin, open("error_logs.txt", "w") as fout:
    for line in fin:
        if "ERROR" in line:
            fout.write(line)

Filtering lines from a file based on a condition

Option 1 – Incorrect: Writes the entire file without filtering; no lines are selected.
Option 2 – Incorrect: Reads all lines into memory first; also writes every line without filtering.
Option 3 – Incorrect: Uses a list comprehension and joins lines; works correctly but less memory-efficient for large files.
Option 4 – Correct: Iterates line by line, checks if "ERROR" is in the line, and writes it immediately. Efficient and correct for large files.

Step-by-step reasoning:

Open both input and output files using with for safe closure.
Iterate over each line in logs.txt.
Check if the line contains the keyword "ERROR".
If yes, write that line to error_logs.txt.

Example Usage:

with open("logs.txt", "r") as fin, open("error_logs.txt", "w") as fout:
    for line in fin:
        if "ERROR" in line:
            fout.write(line)

Key takeaways:

Iterating line by line is memory-efficient for large files.
Filtering based on a condition avoids unnecessary writes.
Using with ensures files are closed even if errors occur.

You have a binary file `data.bin` containing ASCII text. You want to read it, convert all lowercase letters to uppercase, and write to `output.txt`. Which snippet correctly achieves this?

with open("data.bin", "rb") as fin, open("output.txt", "w") as fout:
    data = fin.read()
    text = data.decode("ascii").upper()
    fout.write(text)

with open("data.bin", "rb") as fin, open("output.txt", "w") as fout:
    fout.write(fin.read().decode("utf-8"))

with open("data.bin", "rb") as fin, open("output.txt", "w") as fout:
    data = fin.read()
    text = data.decode("ascii").upper()
    fout.write(text)

with open("data.bin", "rb") as fin, open("output.txt", "w") as fout:
    fout.write(fin.read())

Converting binary file content to uppercase text

Option 1 – Incorrect: Opens binary file in text mode ("r"), which may fail or misinterpret bytes; also may not handle non-ASCII bytes correctly.
Option 2 – Incorrect: Decodes but does not convert to uppercase; output remains as original text.
Option 3 – Correct: Opens binary file in "rb" mode, reads bytes, decodes as ASCII, converts to uppercase using .upper(), and writes to output in text mode.
Option 4 – Incorrect: Writes raw bytes directly to a text file; no uppercase conversion occurs.

Step-by-step reasoning:

Open data.bin in binary read mode ("rb").
Read all bytes using fin.read().
Decode bytes to string using data.decode("ascii").
Convert text to uppercase using .upper().
Open output.txt in write mode and write transformed text.

Example Usage:

with open("data.bin", "rb") as fin, open("output.txt", "w") as fout:
    data = fin.read()
    text = data.decode("ascii").upper()
    fout.write(text)

Key takeaways:

Binary mode is required to read non-text files correctly.
Decoding is necessary to convert bytes to a string for text operations.
Always handle encoding/decoding carefully to avoid errors when converting binary to text.

Python Working with Files Practice Questions

Which of the following modes opens a file for both reading and writing, without truncating the existing content?

What will be the content of the file data.txt after executing the following code?

You have a text file named info.txt containing the following lines:

What will be printed after executing the following code?

Which of the following statements about using with open() for file operations is correct?

You want to add a new line at the end of log.txt without overwriting the existing content. Which mode should you use?

Which of the following snippets correctly reads the content of example.txt and prints each line in uppercase, ensuring the file is safely closed afterward?

You want to read all lines from data.txt and remove the trailing newline characters from each line. Which snippet achieves this correctly?

Which of the following snippets correctly moves the file pointer to the beginning of the file before reading it again?

You have a very large file bigdata.txt. Which of the following is the most memory-efficient way to read and process it line by line?

Which of the following is the best approach to check if a file exists before reading it, avoiding runtime errors?

You want to write a list of integers [10, 20, 30, 40] to a binary file numbers.bin and then read them back. Which snippet correctly does this?

You have a text containing Unicode characters: "Solviyo – Python Exercises". Which snippet correctly writes this text to a file in UTF-16 encoding and reads it back?

You have a file sample.txt containing multiple lines. You want to read the first 10 characters, move back 5 characters, and then read the next 10 characters. Which snippet achieves this correctly?

You want to read a large file bigfile.txt in chunks of 1024 bytes to avoid memory issues. Which snippet correctly does this?

You want to read a file input.txt, convert all text to uppercase, and write it to output.txt in a memory-efficient way. Which snippet correctly does this?

Consider the following code that recursively reads all .txt files in a directory data/ and counts the total number of lines. Which option correctly implements this?

You want to read the first 15 characters of example.txt, move 7 characters back, and then read 10 characters. Which snippet correctly achieves this?

You want to read largefile.txt in 2048-byte chunks and write each chunk to output.txt, ensuring all data is written correctly even if the last chunk is smaller. Which snippet achieves this?

You want to read logs.txt line by line and write only lines containing the word "ERROR" to error_logs.txt". Which snippet correctly achieves this?

You have a binary file data.bin containing ASCII text. You want to read it, convert all lowercase letters to uppercase, and write to output.txt. Which snippet correctly achieves this?

Explore More Python Exercises

Exception Handling (try-except)

Test Your Python Working with Files Knowledge

About This Exercise: Python – Working with Files

What will be the content of the file `data.txt` after executing the following code?

You have a text file named `info.txt` containing the following lines:

Which of the following statements about using `with open()` for file operations is correct?

You want to add a new line at the end of `log.txt` without overwriting the existing content. Which mode should you use?

Which of the following snippets correctly reads the content of `example.txt` and prints each line in uppercase, ensuring the file is safely closed afterward?

You want to read all lines from `data.txt` and remove the trailing newline characters from each line. Which snippet achieves this correctly?

You have a very large file `bigdata.txt`. Which of the following is the most memory-efficient way to read and process it line by line?

You want to write a list of integers `[10, 20, 30, 40]` to a binary file `numbers.bin` and then read them back. Which snippet correctly does this?

You have a text containing Unicode characters: `"Solviyo – Python Exercises"`. Which snippet correctly writes this text to a file in UTF-16 encoding and reads it back?

You have a file `sample.txt` containing multiple lines. You want to read the first 10 characters, move back 5 characters, and then read the next 10 characters. Which snippet achieves this correctly?

You want to read a large file `bigfile.txt` in chunks of 1024 bytes to avoid memory issues. Which snippet correctly does this?

You want to read a file `input.txt`, convert all text to uppercase, and write it to `output.txt` in a memory-efficient way. Which snippet correctly does this?

Consider the following code that recursively reads all `.txt` files in a directory `data/` and counts the total number of lines. Which option correctly implements this?

You want to read the first 15 characters of `example.txt`, move 7 characters back, and then read 10 characters. Which snippet correctly achieves this?

You want to read `largefile.txt` in 2048-byte chunks and write each chunk to `output.txt`, ensuring all data is written correctly even if the last chunk is smaller. Which snippet achieves this?

You want to read `logs.txt` line by line and write only lines containing the word `"ERROR"` to `error_logs.txt"`. Which snippet correctly achieves this?

You have a binary file `data.bin` containing ASCII text. You want to read it, convert all lowercase letters to uppercase, and write to `output.txt`. Which snippet correctly achieves this?