PCAP Exceptions and File I/O Practice Test 5 — 15 Questions

Question 1

What will be printed?

Accepted Answer

None. The code attempts to open a file for reading that does not exist, which raises a FileNotFoundError. Since the except clause only catches IOError, and FileNotFoundError is a subclass of OSError, not IOError (in Python 3), the exception is not caught. The program terminates with an unhandled exception, so nothing is printed, and the output is None.

Answer

-1

Answer

0

Answer

An exception is raised.

Question 2

If the file 'log_output.txt' contains the lines shown, what is the actual output?

Accepted Answer

ERROR: Disk full. Option B is correct because the code likely uses a try-except block that catches an exception and prints 'ERROR: Disk full' to the file. The question states that the file contains the lines shown, and the actual output is the content written to the file, which matches 'ERROR: Disk full' exactly. The other options include additional lines or different formatting that do not appear in the given file content.

Answer

ERROR

Answer

INFO: Process started
ERROR: Disk full

Answer

ERROR: Disk full
WARN: Memory high

Question 3

If the file 'config.json' exists but contains invalid JSON, what is printed?

Accepted Answer

Invalid JSON. Option D is correct because the code explicitly catches `json.JSONDecodeError` (or `ValueError` in older Python versions) when parsing the file content. If the JSON is invalid, this exception is raised and caught by the `except (json.JSONDecodeError, ValueError)` block, which prints 'Invalid JSON'. The file exists, so the `except FileNotFoundError` block is not triggered.

Answer

Unexpected error

Answer

The program crashes with an unhandled exception.

Answer

Missing config file

Question 4

A developer writes a script to read a configuration file that may not exist. The script should handle the error gracefully and continue. Which approach is most Pythonic?

Accepted Answer

Use a try-except block catching FileNotFoundError. Option A is correct because it directly catches the specific `FileNotFoundError` exception, which is a subclass of `OSError` and is raised when a file does not exist. This approach follows the Pythonic principle of EAFP (Easier to Ask for Forgiveness than Permission), allowing the script to attempt the operation and handle the failure gracefully without redundant checks.

Answer

Use a try-except block catching OSError

Answer

Use os.path.exists to check, then open if it exists

Answer

Use an if statement to check file size

Question 5

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'). Option A is correct because the 'with' statement provides a context manager that automatically closes the file, ensuring closure even if an exception occurs. Option B also guarantees closure but is less idiomatic. Option C does not handle exceptions. Option D may not close on some exceptions.

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 6

A Python application processes user-uploaded files. The requirement is to catch any I/O-related exception while reading the file, but not to catch KeyboardInterrupt or SystemExit. Which exception type should be caught?

Accepted Answer

OSError. Option A is correct because `OSError` is the base class for all I/O-related exceptions in Python 3, including file reading errors like `FileNotFoundError` and `PermissionError`. It does not catch `KeyboardInterrupt` or `SystemExit`, which inherit directly from `BaseException`, not `Exception`. This makes `OSError` the precise choice for catching I/O errors while allowing program termination signals to propagate.

Answer

IOError

Answer

Exception

Answer

BaseException

Question 7

A developer is implementing a custom exception for invalid data. Which class should the custom exception inherit from?

Accepted Answer

Exception. Option D is correct because the `Exception` class is the base class for all built-in, non-system-exiting exceptions in Python. Custom exceptions should inherit from `Exception` (or one of its subclasses) to ensure they are caught by generic `except Exception:` handlers and integrate properly with Python's exception hierarchy, while avoiding the system-exiting exceptions derived from `BaseException`.

Answer

RuntimeError

Answer

ArithmeticError

Answer

BaseException

Question 8

Which TWO of the following are true about the 'with' statement in Python file I/O?

Accepted Answer

It is equivalent to a try/finally block. Option B is correct because the 'with' statement in Python is designed to simplify exception handling by encapsulating the setup and teardown of a resource in a context manager, which is functionally equivalent to a try/finally block. When you use 'with', the context manager's __exit__ method is guaranteed to be called even if an exception occurs, ensuring that cleanup actions like closing a file are performed, just as a finally clause would.

Answer

It can only be used with file objects

Answer

It does not require an __exit__ method

Answer

It requires the object to have an __enter__ method only

Question 9

Which THREE of the following exception types are subclasses of OSError in Python 3?

Accepted Answer

FileNotFoundError. FileNotFoundError is a direct subclass of OSError, raised when a file or directory is requested but does not exist at the given path. This is part of Python's exception hierarchy for operating system-related errors, specifically for file operations that fail due to missing resources.

Answer

UnicodeError

Answer

EOFError

Question 10

Which TWO of the following are correct ways to raise a custom exception in Python? (Assume CustomError and CustomException are user-defined.)

Accepted Answer

raise CustomError("invalid"). Option C is correct because it raises a user-defined exception by instantiating the custom exception class `CustomError` with an argument (the string "invalid"). In Python, the `raise` statement must be followed by an exception instance or an exception class; `CustomError("invalid")` creates an instance of the custom exception, which is the proper way to raise a custom exception with a custom message.

Answer

raise "Custom error"

Answer

raise 42

Answer

raise Exception

Question 11

A company runs a data processing pipeline that reads CSV files from a network drive. Occasionally, the network drive is unreachable causing FileNotFoundError. The current code uses a bare except clause that catches all exceptions, which also masks programming errors like NameError. The lead developer wants to implement a more robust exception handling strategy. The requirement is to log the specific error (including the filename) and retry the operation up to 3 times with a 2-second delay between retries. If after 3 attempts the file is still inaccessible, the pipeline should skip the file and continue with the next one. Which approach best meets these requirements?

Accepted Answer

Use a try-except block catching OSError, with a retry loop that logs the error and continues after max retries.. Option B is correct because it catches OSError, which is the parent class for file-related errors like FileNotFoundError, while still allowing programming errors like NameError to propagate. The retry loop with a 2-second delay and a maximum of 3 attempts satisfies the requirement, and after exhausting retries, the loop naturally continues to the next file, skipping the problematic one.

Answer

Use os.path.exists before opening the file, and if it returns False, log and skip.

Answer

Use a try-except block catching Exception, with a retry loop and logging.

Answer

Use a with statement; if an exception occurs, call the function recursively up to 3 times.

Question 12

A small web application allows users to download files from a server. The code uses open() without any exception handling. When a user requests a non-existent file, the server crashes with a traceback and returns a 500 Internal Server Error to the client. The team needs to modify the code to handle this situation gracefully: if the file does not exist, the application should return a 404 Not Found response (by calling a function send_404()). The application should not catch unrelated exceptions like KeyboardInterrupt. Which modification is the most appropriate?

Accepted Answer

Wrap the open() call in a try-except block catching FileNotFoundError, and in the except block call send_404().. Option D is correct because it catches the specific exception raised when a file is not found (FileNotFoundError), which is a subclass of OSError. This allows the code to return a 404 response for missing files while not catching unrelated exceptions like KeyboardInterrupt, as required. The except block calls send_404() to handle the missing file gracefully without crashing the server.

Answer

Wrap the entire request handling in a try-except block catching Exception, and if any exception occurs, call send_500().

Answer

Check if the file exists using os.path.exists before opening, and if not, call send_404().

Answer

Wrap the open() call in a try-except block catching OSError, and in the except block call send_404().

Question 13

A senior developer in a team argues that using try-except blocks is slower than checking conditions with if statements. They propose replacing all try blocks that handle file I/O errors with existence checks using os.path.exists before opening files. During a code review, you recall that Python's official documentation and best practices prefer EAFP (Easier to Ask for Forgiveness than Permission) over LBYL (Look Before You Leap) in many cases, especially in concurrent environments. The team's application is a multi-threaded web server that serves static files from a shared directory. Which is the strongest counterargument against the senior developer's proposal?

Accepted Answer

LBYL leads to race conditions in concurrent code because the file's state can change between the check and the use.. Option D is correct because in a multi-threaded web server, the LBYL approach (checking with os.path.exists) introduces a classic TOCTOU (Time of Check, Time of Use) race condition: between the existence check and the actual file open, another thread could delete or rename the file, causing the open to fail despite the check passing. Python's EAFP idiom (try-except) avoids this window by attempting the operation directly and handling the exception if it fails, which is inherently atomic with respect to the file system state. This is why official Python documentation recommends EAFP over LBYL in concurrent environments.

Answer

if statements are harder to read and maintain.

Answer

try-except can catch multiple exception types more cleanly.

Answer

try-except blocks have no performance cost at all.

Question 14

A data scientist writes a script to parse a configuration file that contains lines in 'key=value' format. Some lines may have malformed data that cause a ValueError when trying to convert the value to an integer. The requirement is to process all valid lines and skip any that cause a ValueError, but continue processing subsequent lines. The script should log a warning for each skipped line, including the line number. Which implementation correctly fulfills this requirement? (Assume the file is opened with 'with open(...) as f'.)

Accepted Answer

Inside a for loop over f, wrap the parsing in a try-except ValueError block, log the error, and continue.. Option A is correct because it uses a try-except ValueError block inside the for loop, which catches the specific exception when converting the value to an integer, logs a warning with the line number, and continues to the next line. This ensures all valid lines are processed while malformed lines are skipped without halting execution, fulfilling the requirement exactly.

Answer

Wrap the entire file processing in a try-except ValueError block; if an error occurs, log and break.

Answer

Before parsing, check if the value string consists of digits using str.isdigit; if not, skip the line.

Answer

Inside a for loop over f, wrap the parsing in a try-except Exception block, log the error, and continue.

Question 15

A programmer needs to write a function that reads a large binary file (over 1 GB) and returns its entire content as a bytes object. The function must handle the case where the path provided is actually a directory (IsADirectoryError) by returning an empty bytes object. Which implementation is most memory-efficient and correctly handles the directory case? Consider that reading the entire file into memory is acceptable for the business case.

Accepted Answer

Use 'with open(path, 'rb') as f: return f.read()' inside a try-except IsADirectoryError catch that returns b''.. Option A is correct because it uses a try-except block specifically catching `IsADirectoryError`, which is raised when `open()` is called on a directory path. The `with` statement ensures the file is properly closed, and `f.read()` returns the entire content as a bytes object, which is memory-efficient for this use case (the file is read in one large allocation, avoiding overhead from chunking).

Answer

Use 'with open(path, 'rb') as f: return f.read()' inside a try-except OSError that returns b''.

Answer

Use os.path.isfile(path) to check before opening; if not a file, return b''.

Answer

Use 'with open(path, 'rb') as f: return [chunk for chunk in iter(lambda: f.read(1024), b'')]' inside a try-except IsADirectoryError.

PCAP Exceptions and File I/O Practice Test 5 — 15 Questions

Exhibit

PCAP Exceptions and File I/O Practice Test 5 — 15 Questions

Exhibit