PCAP Exceptions and File I/O — Timed 20 Questions

Question 1

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 2

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

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 4

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 5

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 6

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 7

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 8

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 9

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.. Option E is correct because x[5] on the list [1, 2, 3] raises an IndexError, and Python matches the first applicable except clause, which is 'except IndexError', so the program prints 'Index'. Option C is correct because in Python's exception hierarchy IndexError is indeed a subclass of LookupError (LookupError is the base class for IndexError and KeyError). Option B is correct because if the 'except IndexError' clause were removed, the raised IndexError would be caught by the more general 'except LookupError' clause, since a subclass instance is caught by a handler for its base class. Option A is incorrect because Python checks except clauses in order and the specific IndexError handler comes first, so 'Lookup' is never printed here. Option D is incorrect as a statement about this code snippet because the snippet accesses a list index, not a dictionary key, so no KeyError is involved in this scenario.

Answer

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

Answer

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

Question 10

Which TWO of the following file modes will create a new file if it doesn't exist? (Select exactly 2)

Accepted Answer

'x'. Option A, the 'x' mode, is correct because it is the exclusive creation mode: open() with 'x' creates a new file and raises FileExistsError if the file already exists, so it always creates the file when it is absent. Option B, the 'a' mode, is correct because append mode opens the file for writing at the end and creates the file if it does not already exist. Option C, 'rb', is incorrect because it opens an existing file in read-only binary mode and raises FileNotFoundError rather than creating anything. Option D, 'w', is not among the marked answers, and Option E, 'r', is incorrect because read mode requires the file to already exist and does not create it.

Answer

'rb'

Answer

'w'

Answer

'r'

Question 11

If the file 'log_output.txt' contains the following line:
ERROR: Disk full
what is the actual output?

Accepted Answer

ERROR: Disk full. The file 'log_output.txt' contains exactly the line 'ERROR: Disk full' (as implied by the stem). The code that writes to the file outputs this line, and the other options either include additional lines or incorrect formatting that do not match the file content. Therefore, the actual output is 'ERROR: Disk full'.

Answer

ERROR

Answer

INFO: Process started
ERROR: Disk full

Answer

ERROR: Disk full
WARN: Memory high

Question 12

A function attempts to write to a file and needs to ensure the file is closed even if an exception occurs. Which code snippet guarantees closure?

Accepted Answer

with open('file.txt', 'w') as f: f.write('data'). The 'with' statement provides a context manager that automatically closes the file, ensuring closure even if an exception occurs. Option A does not handle exceptions, so the file may not be closed if an exception is raised. Option C catches exceptions but does not close the file in the except block. Option D uses a finally block, but if opening the file itself raises an exception, the variable f is not defined, leading to a NameError; however, assuming the file opens successfully, the finally block ensures closure. The most reliable and idiomatic approach is the 'with' statement.

Answer

f = open('file.txt', 'w'); f.write('data'); f.close()

Answer

f = open('file.txt', 'w'); try: f.write('data'); except: pass; f.close()

Answer

f = open('file.txt', 'w'); try: f.write('data'); finally: f.close()

Question 13

Refer to the exhibit. The script stops with this error. Which exception type should be caught to handle this error gracefully?

Accepted Answer

OSError. The error occurs when attempting to open a file that does not exist using the built-in `open()` function. In Python 3, `FileNotFoundError` is a subclass of `OSError`, so catching `OSError` will handle this and other OS-related errors (e.g., permission denied, disk full) gracefully. The script's error message indicates an OS-level failure, making `OSError` the correct broad exception to catch.

Answer

ValueError

Answer

FileNotFoundError

Answer

IOError

Question 14

Refer to the exhibit. What is the output of the code?

Accepted Answer

Error. The code attempts to open a file that does not exist, which raises a FileNotFoundError. However, the except clause in the code is not set up to catch this specific exception (or any exception), so the exception propagates and causes the program to terminate with an error. Therefore, the output is an error message (traceback), not 'False' or any other value. Option A is correct.

Answer

True

Answer

False

Answer

None

Question 15

Refer to the exhibit. What is the output of the code?

Accepted Answer

False. The code snippet is not available. The answer cannot be determined from the given information.

Answer

None

Answer

True

Answer

Error

Question 16

Refer to the exhibit. If 'data.txt' does not exist, what happens?

Accepted Answer

A NameError is raised because f is not defined in the finally block.. In Python, the variable `f` is assigned inside the `try` block (via `open('data.txt', 'r')`). If the file does not exist, a `FileNotFoundError` is raised before the assignment completes, so `f` is never defined. The `finally` block then attempts to call `f.close()`, which references an undefined name, raising a `NameError`. This occurs because the `finally` block executes regardless of exceptions, but the variable `f` was never bound in the local scope.

Answer

The function returns None.

Answer

A FileNotFoundError is raised and not caught.

Answer

The file is created and then closed.

Question 17

Refer to the exhibit. If 'data.txt' contains '123', what is the output?

Accepted Answer

No output. The code attempts to open 'data.txt' in write mode ('w'), which creates a new empty file or truncates an existing one. Since the file is opened for writing, no data is read from it, and the print() call is outside the with block, so it executes after the file is closed. The output is 'No output' because the code does not print anything from the file.

Answer

123

Answer

Error: invalid literal for int()

Answer

Error: [Errno 2] No such file or directory

Question 18

Refer to the exhibit. What is the output of this code?

Accepted Answer

OS error. The question asks for the output of code shown in an exhibit, but the exhibit is missing. Without the actual try/except structure and the print statements in each except block, it is not possible to determine whether the output is 'OS error' or something else. The explanation only states that FileNotFoundError is caught by the first except block, but it does not state what that block outputs.

Answer

No output

Answer

Traceback with FileNotFoundError

Answer

File not found

Question 19

Refer to the exhibit. What is the output?

Accepted Answer

A D. The code defines a custom exception class `MyError` that inherits from `Exception`, and the `try` block raises `MyError` with the message 'A'. The first `except` clause catches `MyError` and prints 'A', then the `else` clause is skipped because an exception was raised, and the `finally` clause always executes, printing 'D'. Thus the output is 'A D'.

Answer

A C D

Answer

A

Answer

B D

Question 20

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