PCAP Exceptions and File I/O — 20 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. `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.. 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

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'). 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 4

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 5

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 6

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

Accepted Answer

except (FileNotFoundError, PermissionError):. 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 7

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

Accepted Answer

raise Exception. In Python, `raise Exception` is valid syntax; it raises an instance of `Exception` with no arguments. `raise Exception('error')` and `raise ValueError('invalid value')` are also valid. Therefore, the correct answer choices are B, D, and E, not just D and E.

Answer

raise

Answer

throw ValueError('error')

Question 8

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.. 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 9

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 10

What is the output of the code?

```python
with open('log.txt') as f:
    for line in f:
        if 'ERROR' in line:
            print('Error found:', line)
            break
```

Accepted Answer

Error found: 2025-03-15 10:23:45 ERROR: Division by zero in module calc.py line 42. The code (which is not shown in the question) reads a log file line by line. It checks if each line contains the substring 'ERROR'. Upon finding the first such 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 and then breaks out of the loop. Therefore, only that line is printed, matching option D.

Answer

Prints all lines in the file.

Answer

Raises an unhandled exception.

Answer

Prints all lines containing 'ERROR'

Question 11

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

Catch OSError and re-open the file within the except block, then continue reading.. The most likely cause is that the external process manipulating the file leads to an invalid file descriptor. Catching OSError and re-opening the file provides a fresh descriptor and allows the script to continue without relying on the external process to use file locking. This approach is simpler and more robust in environments where the external process may not support locking.

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

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.

Question 12

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

Accepted Answer

Import the csv module, open the CSV file, create a csv.reader object, iterate over the reader to access each row, close the file.. Reading a CSV file requires importing csv, opening the file, creating a reader, iterating rows, and closing the file.

Answer

Open the CSV file, import the csv module, create a csv.reader object, iterate over the reader to access each row, close the file.

Answer

Import the csv module, create a csv.reader object, open the CSV file, iterate over the reader to access each row, close the file.

Answer

Import the csv module, open the CSV file, iterate over the reader to access each row, create a csv.reader object, close the file.

Question 13

Match each Python module to its purpose.

Accepted Answer

os: Provides a portable way of using operating system dependent functionality.. Common Python standard library modules: os (operating system interface), sys (interpreter access), json (JSON handling), datetime (date and time), re (regular expressions), math (mathematical functions).

Answer

os: Provides access to some variables used or maintained by the interpreter.

Answer

sys: Provides functions for working with dates and times.

Answer

json: Provides support for regular expressions.

Question 14

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'). 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')

Question 15

A developer is implementing a custom context manager to manage database connections. The context manager should automatically roll back the transaction if an exception occurs, but commit if no exception occurs. Which pattern ensures this behavior correctly?

Accepted Answer

def __exit__(self, exc_type, exc_val, exc_tb):
    if exc_type:
        self.connection.rollback()
    else:
        self.connection.commit(). The __exit__ method receives exc_type, exc_val, exc_tb. When no exception occurs, all three are None. When an exception occurs, exc_type is the exception class, exc_val is the exception instance (never None), and exc_tb is the traceback. Therefore checking either exc_type or exc_val correctly differentiates normal completion from exception. Both B and D ensure rollback on exception and commit otherwise.

Answer

def __exit__(self, exc_type, exc_val, exc_tb): self.connection.commit()

Answer

def __exit__(self, exc_type, exc_val, exc_tb): self.connection.rollback()

Question 16

A developer needs to write binary data to a file. Which file mode should be used to open the file for writing in binary mode without truncating it if it already exists?

Accepted Answer

'ab'. ('ab') is correct because the 'a' mode opens the file for appending, which writes data at the end without truncating the existing content, and adding 'b' specifies binary mode. This allows binary data to be written to a file that already exists without losing its current contents.

Answer

'wb'

Answer

'rb'

Answer

'wb+'

Question 17

A developer has a function that performs several operations and may raise different exceptions. The developer wants to catch a specific exception and then re-raise it after logging. Which code snippet correctly re-raises the same exception without losing its traceback?

Accepted Answer

except ValueError as e: log.error(e); raise. Using a bare `raise` statement inside an `except` block re-raises the original exception instance, preserving its full traceback. This is the standard Python idiom for logging an exception and then propagating it unchanged, ensuring that the original call stack and error context are not lost.

Answer

except ValueError as e: log.error(e); return None

Answer

except ValueError as e: log.error(e); raise ValueError('New')

Answer

except ValueError as e: log.error(e); pass

Question 18

A developer writes a script that opens a file for reading. The script must ensure that the file is closed even if an exception occurs during reading. Which pattern guarantees proper resource cleanup?

Accepted Answer

file = open('data.txt'); try: # read; finally: file.close(). Both option A and option C guarantee that the file is closed if an exception occurs during reading. Option A uses try/finally, which executes finally even on exceptions, and since the open() succeeds before the try block, there is no NameError. Option C uses the with statement, which is the recommended Pythonic approach and also guarantees cleanup via the context manager protocol.

Answer

file = open('data.txt'); # read; file.close()

Answer

file = open('data.txt'); if not file.closed: file.close()

Question 19

Which TWO statements about exception handling in Python are correct? (Select exactly 2.)

Accepted Answer

A single except clause can catch multiple exception types by passing a tuple of exceptions.. Python's except clause accepts a tuple of exception types, allowing a single handler to catch multiple exception types. For example, `except (ValueError, TypeError):` will catch either exception, which is a concise way to handle related errors without duplicating code.

Answer

The order of except clauses does not matter because only one will match.

Answer

An else block can be used without any except blocks in a try statement.

Answer

The else block in a try statement executes only if an exception was raised.

Question 20

Consider the following code snippet:

x = [1, 2, 3]
try:
    print(x[5])
except IndexError:
    print('Index')
except LookupError:
    print('Lookup')

Which THREE statements about this code are correct? (Select exactly 3.)

Accepted Answer

If the line with IndexError is removed, then LookupError will catch the exception.. Options B, C, and E are correct. Option B is true because removing IndexError leaves LookupError to catch the exception. Option C is a fact about Python's exception hierarchy. Option E matches the actual output. Option D is not about the given code; it discusses a hypothetical scenario that is not part of the code snippet.

Answer

The code will print 'Lookup' because LookupError is more general.

Answer

If the code were accessing a dictionary key, LookupError would catch KeyError.