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

Question 1

Refer to the exhibit. If the file config.cfg exists but the user does not have read permission, what will be printed?

Accepted Answer

'Permission denied'. When the `open()` function is called on a file that exists but the user lacks read permission, Python raises a `PermissionError` exception. The code does not include a try-except block to handle this exception, so the program terminates with an unhandled exception and prints the error message 'Permission denied' (the string representation of the exception). Option B is correct because that is the default behavior of Python when such an exception is not caught.

Answer

An unhandled exception is raised

Answer

Nothing; the program continues silently

Answer

'File not found'

Question 2

Refer to the exhibit. Which of the following Python code snippets would generate this error?

Accepted Answer

int('abc'). Option A is correct because `int('abc')` attempts to convert the string `'abc'` to an integer, which is not a valid numeric literal. Python raises a `ValueError` with the message 'invalid literal for int() with base 10: 'abc''. This error occurs because the `int()` function expects a string that represents a valid integer in the specified base (default base 10), and 'abc' does not meet that criterion.

Answer

str(123)

Answer

print('abc')

Answer

float('abc')

Question 3

Refer to the exhibit. If both data.txt and backup.txt do not exist, what is the output?

Accepted Answer

'No file found'. Option D is correct because the code uses a try-except block to catch FileNotFoundError when attempting to open 'data.txt'. In the except block, it prints 'No file found' and then attempts to open 'backup.txt'. Since both files do not exist, the except block executes and prints 'No file found' before the second open attempt raises another FileNotFoundError, which is unhandled and terminates the program. However, the question asks for the output, which is the print statement executed before the error.

Answer

Prints contents of backup.txt

Answer

Nothing

Answer

FileNotFoundError

Question 4

In Python, if you have a try block followed by an except clause that catches all exceptions, which of the following is true about the else clause?

Accepted Answer

The else clause runs only if no exception is raised in the try block.. In Python, the `else` clause in a `try` statement executes only if no exception was raised in the `try` block. This is true regardless of whether the `except` clause catches all exceptions (e.g., bare `except:` or `except Exception:`). The `else` block is specifically designed for code that should run only when the `try` block completes successfully without any exception.

Answer

The else clause runs only if an exception occurs.

Answer

The else clause runs before the finally block regardless of exceptions.

Answer

The else clause is used to specify additional exception handlers.

Question 5

A developer needs to write a function that safely divides two numbers and returns None if division by zero occurs. Which implementation is most Pythonic?

Accepted Answer

def safe_divide(a, b):
    try:
        return a/b
    except ZeroDivisionError:
        return None. Option A is correct because it uses a try-except block to catch the specific ZeroDivisionError that Python raises when dividing by zero. This is the most Pythonic approach, following the EAFP (Easier to Ask for Forgiveness than Permission) principle, which is preferred over LBYL (Look Before You Leap) in Python. The function returns None only when the exception occurs, preserving the natural behavior of division for all other cases.

Answer

def safe_divide(a, b):
    return a/b if b else None

Answer

def safe_divide(a, b):
    if b != 0:
        return a/b
    else:
        return None

Answer

def safe_divide(a, b):
    try:
        return a/b
    except ValueError:
        return None

Question 6

Consider the code fragment: 
    f = open('data.txt', 'r')
    data = f.read()
    process_data(data)
    f.close()
What is the primary risk if an exception occurs during process_data(data)?

Accepted Answer

The file descriptor may be leaked because the close() call is skipped.. Option A is correct because if `process_data(data)` raises an exception, the `f.close()` statement is never executed, leaving the file descriptor open. This is a resource leak that can exhaust system file handles, especially in long-running applications. Python's `with` statement is the recommended approach to guarantee automatic cleanup even when exceptions occur.

Answer

The exception will be silently suppressed.

Answer

The file will be automatically closed by Python's garbage collector immediately.

Answer

The file contents will be corrupted.

Question 7

Which mode should be used when opening a file for writing such that new content is appended to the end without truncating existing content?

Accepted Answer

'a'. Option D ('a') is correct because the 'a' mode opens a file for appending, which means new data is written to the end of the file without truncating any existing content. This is the standard behavior defined in Python's open() function for append mode.

Answer

'x'

Answer

'r+'

Answer

'w'

Question 8

A Python script that processes log files uses the following code:
    with open('log.txt', 'r') as f:
        lines = f.readlines()
    for line in lines:
        # process
What is a potential inefficiency in this code?

Accepted Answer

Reading the entire file into memory may be wasteful for large files.. Option B is correct because `readlines()` loads the entire file into memory as a list of strings. For large log files, this can consume significant memory and cause performance degradation or even memory errors. A more memory-efficient approach is to iterate directly over the file object (e.g., `for line in f:`), which reads one line at a time from disk.

Answer

The file is not properly closed after processing.

Answer

Using readlines() is the most efficient way to iterate over lines.

Answer

The file should be opened in binary mode for better performance.

Question 9

Which of the following exception classes is NOT a direct subclass of Exception in Python?

Accepted Answer

SystemExit. SystemExit is not a direct subclass of Exception; it inherits from BaseException instead. This is because SystemExit, along with KeyboardInterrupt and GeneratorExit, is intended to signal that the interpreter should exit, and catching it with a generic except Exception clause would be inappropriate. All other options (IOError, StopIteration, ValueError) are direct subclasses of Exception.

Answer

IOError

Answer

StopIteration

Answer

ValueError

Question 10

What will be the output of the following code?
    try:
        print(1/0)
    except:
        print('error')
    else:
        print('no error')
    finally:
        print('done')

Accepted Answer

error
done. Option D is correct because the code raises a ZeroDivisionError when attempting 1/0, which is caught by the bare except clause, printing 'error'. The else clause is skipped because an exception occurred. The finally clause always executes, printing 'done'. Thus the output is 'error' followed by 'done'.

Answer

no error
done

Answer

error
no error
done

Answer

done

Question 11

A developer wants to ensure that a file is always closed, even if an exception occurs, without using the 'with' statement. Which approach correctly achieves this?

Accepted Answer

f = open('file.txt'); try: ... finally: f.close(). Option B is correct because the `finally` block is guaranteed to execute regardless of whether an exception occurs in the `try` block. This ensures that `f.close()` is always called, properly releasing the file resource. The `with` statement is not used, but the `try...finally` construct provides the same deterministic cleanup behavior.

Answer

f = open('file.txt'); try: ... except: ... else: f.close()

Answer

if f.closed: pass else: f.close()

Answer

try: f = open('file.txt'); ... except: pass; finally: f.close()

Question 12

When should you raise a specific exception class rather than a generic Exception?

Accepted Answer

When different error conditions require different handling.. Raising a specific exception class (e.g., ValueError, KeyError, or a custom subclass) allows the caller to catch and handle each error condition differently using separate except blocks. Using a generic Exception forces all errors into a single handler, which can mask distinct failure modes and make debugging harder. This aligns with Python's EAFP (Easier to Ask for Forgiveness than Permission) idiom, where precise exception types enable fine-grained error recovery.

Answer

Always raise Exception for simplicity.

Answer

Specific exceptions cannot be created; only built-in ones can be used.

Answer

Only when performance is a concern.

Question 13

Which TWO of the following are valid ways to read a file line by line without loading the entire file into memory?

Accepted Answer

for line in f:. Option B is correct because iterating directly over a file object with `for line in f:` reads one line at a time from the file's internal buffer, never loading the entire file into memory. This is the idiomatic and memory-efficient way to process large files line by line in Python.

Answer

lines = list(f)

Answer

contents = f.read().split('
')

Answer

lines = f.readlines()

Question 14

Which THREE of the following are true about Python's exception hierarchy?

Accepted Answer

KeyboardInterrupt inherits from BaseException.. Option A is correct because `KeyboardInterrupt` inherits directly from `BaseException`, not from `Exception`. This design ensures that `KeyboardInterrupt` (raised by Ctrl+C) is not caught by a generic `except Exception:` clause, allowing the program to be interrupted even when broad exception handling is in place.

Answer

IOError is a separate class from OSError.

Answer

GeneratorExit inherits from Exception.

Question 15

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

Accepted Answer

It ensures the file is closed when the block exits.. Option A is correct because the 'with' statement in Python acts as a context manager that automatically calls the file object's __exit__ method when the block exits, which in turn invokes the file's close() method. This guarantees that the file is properly closed, even if an exception occurs within the block, ensuring deterministic resource cleanup.

Answer

It can only be used with file objects.

Answer

It automatically opens the file without needing open().

Answer

It prevents any exception from occurring during file operations.

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

Exhibit

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

Exhibit