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

Question 1

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 2

Consider the following code:

import json

try:
    with open('config.json') as f:
        data = json.load(f)
except FileNotFoundError:
    print("Missing config file")
except json.JSONDecodeError:
    print("Invalid JSON")
except:
    print("Unexpected error")

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

Accepted Answer

Invalid JSON. When the file exists but contains invalid JSON, attempting to parse it raises a json.JSONDecodeError. A program designed to handle this exception will catch it and print 'Invalid JSON', as indicated by option D. Options A and B are incorrect because the error is specifically a JSON parsing error, not an unexpected error or an unhandled crash. Option C is incorrect because the file does exist, so no file-not-found error occurs.

Answer

Unexpected error

Answer

The program crashes with an unhandled exception.

Answer

Missing config file

Question 3

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 4

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. `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 5

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

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 7

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"). 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 8

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

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().. 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 10

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

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

Question 12

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 13

Refer to the exhibit. What does the 'from None' clause do in the second raise statement?

Accepted Answer

It prevents chaining of exceptions, so only the final exception is displayed.. In Python, the 'from None' clause in a raise statement explicitly suppresses exception chaining. Normally, when an exception is raised inside an except block, Python automatically chains the new exception to the original one using the __cause__ attribute. Using 'raise NewException from None' sets __cause__ to None, which prevents the interpreter from displaying the original exception's traceback, so only the final exception is shown.

Answer

It causes the original exception to be ignored.

Answer

It causes both exceptions to be raised simultaneously.

Answer

It replaces the original exception with a new one.

Question 14

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 15

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.