PCAP Exceptions and File I/O — Timed 40 Questions

Question 1

A developer writes a function that reads a configuration file and returns its contents as a string. The file might not exist. Which exception should be caught to handle a missing file?

Accepted Answer

FileNotFoundError. Option A is correct because `FileNotFoundError` is a built-in exception in Python that is raised when a file or directory is requested but does not exist. In Python 3, file-related I/O errors are organized under `OSError` with specific subclasses, and `FileNotFoundError` is the precise exception for a missing file, making it the most appropriate catch for this scenario.

Answer

PermissionError

Answer

IOError

Answer

OSError

Question 2

A Python script processes a log file line by line. If a line cannot be decoded due to an encoding error, the script should skip the line and continue. Which exception handling approach is best?

Accepted Answer

Inside the loop, wrap the line decoding in a try-except UnicodeDecodeError block and continue.. Option C is correct because it places the try-except block inside the loop, specifically catching `UnicodeDecodeError` for each line. This allows the script to skip only the problematic line and continue processing subsequent lines, which matches the requirement exactly.

Answer

Wrap the entire file reading in a try-except block without specifying exception type.

Answer

Use a try-except-else block to handle success and failure separately, exiting on failure.

Answer

Catch Exception in the outer loop and break on error.

Question 3

A developer implements a custom exception class `DataError` that inherits from `Exception`. Which method override is essential to ensure the exception message is properly displayed when caught?

Accepted Answer

Override __init__ to accept a message and call super().__init__(message).. Option A is correct because the `Exception` class's `__init__` method stores the message argument in the `args` attribute, which is used by the default `__str__` method to display the message. By overriding `__init__` to accept a message and call `super().__init__(message)`, the custom exception properly passes the message to the base class, ensuring it is displayed when caught and printed.

Answer

Set the __cause__ attribute in __init__.

Answer

Override __str__ to return a formatted string.

Answer

Override __repr__ to return a detailed representation.

Question 4

Which of the following is the correct way to open a file for writing in text mode, ensuring that if the file already exists it will be overwritten?

Accepted Answer

open('file.txt', 'w'). Option B is correct because the 'w' mode opens the file for writing in text mode and truncates the file to zero length if it exists, or creates a new file if it does not. This ensures any existing content is overwritten, which matches the requirement.

Answer

open('file.txt', 'x')

Answer

open('file.txt', 'r+')

Answer

open('file.txt', 'a')

Question 5

A script uses `with open('data.bin', 'rb') as f:` to read binary data. Within the block, which method should be used to read exactly 4 bytes?

Accepted Answer

f.read(4). The `read(n)` method reads exactly `n` bytes from the file object when the file is opened in binary mode (`'rb'`). Since the question specifies reading exactly 4 bytes, `f.read(4)` is the correct and direct approach. This method returns a bytes object of up to `n` bytes, but if the file has at least 4 bytes remaining, it will return exactly 4.

Answer

f.seek(4)

Answer

f.readline()

Answer

f.read()

Question 6

Consider the following code snippet:

try:
    x = int(input())
    y = 10 / x
    print(y)
except ZeroDivisionError:
    print('Division by zero')
except ValueError:
    print('Invalid integer')

If the user enters '0', what is the output?

Accepted Answer

Division by zero. When the user enters '0', the input is successfully converted to the integer 0 by int(), so no ValueError occurs. Then 10 / 0 raises a ZeroDivisionError, which is caught by the except ZeroDivisionError block, printing 'Division by zero'. Option C is correct because the code never reaches the ValueError handler.

Answer

No output

Answer

Both 'Invalid integer' and 'Division by zero'

Answer

Invalid integer

Question 7

Which of the following statements about the `finally` block is true?

Accepted Answer

It always executes, regardless of exceptions.. Option D is correct because the `finally` block in Python is designed to always execute after the `try` and `except` blocks, regardless of whether an exception was raised or not. This includes cases where a `return`, `break`, or `continue` statement is executed in the `try` block, or even if an unhandled exception occurs. The `finally` block is guaranteed to run before the function returns or the exception propagates, ensuring cleanup actions like closing files or releasing resources.

Answer

It executes only if no exception is raised.

Answer

It does not execute if a return statement is in try block.

Answer

It executes only if an exception is raised.

Question 8

A programmer wants to catch both `FileNotFoundError` and `PermissionError` with a single except clause. Which tuple is correct?

Accepted Answer

except (FileNotFoundError, PermissionError):. Option A is correct because Python's exception handling syntax allows a tuple of exception types in a single `except` clause, enabling the programmer to catch multiple exception types with the same handler. Both `FileNotFoundError` and `PermissionError` are subclasses of `OSError`, but using the tuple explicitly catches only those two specific exceptions, not all `OSError` subtypes.

Answer

except FileNotFoundError, PermissionError:

Answer

except OSError:

Answer

except [FileNotFoundError, PermissionError]:

Question 9

Which TWO of the following are valid ways to raise an exception in Python?

Accepted Answer

raise Exception('error'). Option D is correct because `raise Exception('error')` is the standard Python syntax to raise an exception with a custom message. The `raise` keyword is followed by an exception class (or instance), and passing a string argument provides an error message that is stored in the exception's `args` attribute. This is the most common and explicit way to raise an exception in Python.

Answer

raise

Answer

raise Exception

Answer

throw ValueError('error')

Question 10

Which THREE of the following are true about the `with` statement for file handling?

Accepted Answer

It uses the __enter__ and __exit__ methods of the file object.. Option C is correct because the `with` statement relies on the context management protocol, which requires the object to implement the `__enter__` and `__exit__` methods. When a file object is used with `with`, its `__enter__` method returns the file object itself, and its `__exit__` method is called upon block exit to handle cleanup, such as closing the file.

Answer

It can only be used with files.

Answer

It can only handle one file at a time.

Question 11

Which TWO of the following are built-in Python exceptions?

Accepted Answer

ValueError. ValueError (C) is a built-in Python exception that is raised when a built-in operation or function receives an argument with the correct type but an inappropriate value, such as int('abc'). FileNotFoundError (D) is a built-in exception in Python 3, raised when a file or directory is requested but does not exist, commonly encountered during file I/O operations like open().

Answer

CustomException

Answer

InputError

Answer

FileReadError

Question 12

What is the output of the Python code after reading the config.txt file?

Accepted Answer

8080. The code reads the config.txt file and splits its content by newlines. The first line contains 'port=8080', and after splitting by '=', the second element is '8080'. The int() function converts this string to the integer 8080, which is then printed. Option C is correct because the output is the integer 8080, not a string or quoted form.

Answer

8080 (as string)

Answer

An exception is raised.

Answer

'8080'

Question 13

What is the output of the code?

Accepted Answer

Error found: 2025-03-15 10:23:45 ERROR: Division by zero in module calc.py line 42. The code reads a log file line by line and checks if the line contains the substring 'ERROR'. When it finds the line '2025-03-15 10:23:45 ERROR: Division by zero in module calc.py line 42', it prints 'Error found: ' followed by that line. After printing, it breaks out of the loop, so only the first matching line is output. Option D correctly describes this behavior.

Answer

Prints all lines in the file.

Answer

Raises an unhandled exception.

Answer

Prints all lines containing 'ERROR'

Question 14

You are a Python developer at a financial firm. Your team maintains a high-frequency trading system that reads real-time market data from a binary file 'market_feed.bin'. The file is updated every millisecond by an external process. Your script uses a `with` statement to open the file in binary read mode and reads exactly 1024 bytes each iteration in an infinite loop. Recently, the script has been crashing intermittently with an `OSError` with message '[Errno 9] Bad file descriptor'. The error occurs at random times, sometimes after minutes, sometimes after hours. The system runs on Linux. The script runs as a daemon. You suspect the issue is related to file descriptor exhaustion or the external process manipulating the file. What is the most likely cause and the best course of action?

Accepted Answer

Use file locking (e.g., fcntl.flock) to coordinate access with the external process, and re-open the file if a lock cannot be acquired.. The most likely cause is that the external process overwrites or truncates 'market_feed.bin' between reads, causing the file descriptor held by the Python script to become invalid (stale). On Linux, when a file is replaced or truncated by another process, the original file descriptor may point to a deleted inode, and subsequent reads yield 'Bad file descriptor'. Option D is correct because file locking (e.g., fcntl.flock with LOCK_SH or LOCK_EX) coordinates access, and re-opening the file after a lock failure ensures a fresh, valid descriptor.

Answer

Open the file without using a context manager and manually close it after each read.

Answer

Increase the read buffer size to 4096 bytes to reduce the number of read operations.

Answer

Catch OSError and re-open the file within the except block, then continue reading.

Question 15

Drag and drop the steps to read a CSV file using the csv module in Python into the correct order.

Question 16

Drag and drop the steps to serialize a Python object to JSON using the json module into the correct order.

Question 17

Match each Python data structure to its mutability.

Question 18

Match each Python module to its purpose.

Question 19

A developer writes a function that reads a file and processes its content. The function should handle the case where the file does not exist without catching other I/O errors. Which exception should be caught?

Accepted Answer

FileNotFoundError. Option D is correct because `FileNotFoundError` is a specific subclass of `OSError` that is raised exactly when a file or directory is requested but does not exist. By catching only `FileNotFoundError`, the function handles the missing-file scenario without masking other I/O errors such as permission issues or disk failures, which is the precise requirement stated in the question.

Answer

PermissionError

Answer

IOError

Answer

OSError

Question 20

A developer is writing a script that processes user-uploaded CSV files. The script should attempt to read the file, and if a UnicodeDecodeError occurs, log a warning and skip the file. Which code snippet correctly achieves this without stopping the entire process?

Accepted Answer

try: read_file() except UnicodeDecodeError: log.warning('Skipping file'). Option B is correct because it catches only UnicodeDecodeError, which is the specific exception raised when a file contains invalid UTF-8 or other encoding issues. It logs a warning and then continues execution (the 'pass' is implied by the log statement, but the key is that the exception is handled without re-raising). This matches the requirement to skip the file without stopping the entire process.

Answer

try: read_file() except (UnicodeDecodeError, OSError): pass

Answer

try: read_file() except Exception: log.warning('Skipping file')

Answer

try: read_file() except UnicodeEncodeError: log.warning('Skipping file')