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

Question 1

Which TWO of the following are appropriate techniques for logging exception details in Python? (Select exactly 2)

Accepted Answer

Using traceback.format_exc(). `traceback.format_exc()` returns the full traceback as a string, which can be logged or printed to capture detailed exception context. Option E is correct because `logging.exception()` automatically includes the traceback of the current exception when called inside an `except` block, making it the idiomatic way to log exceptions in Python.

Answer

Using print(e.args)

Answer

Using sys.exc_info()

Answer

Using raise without argument

Question 2

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 `open()` is called on a file that exists but the user lacks read permission, Python raises a `PermissionError`. Since no exception handling is present, the exception is unhandled and Python prints a traceback to stderr which includes the error message `'Permission denied'` (among other details). Option B correctly identifies the permission-denied message that appears in the output.

Answer

An unhandled exception is raised

Answer

Nothing; the program continues silently

Answer

'File not found'

Question 3

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

Accepted Answer

int('abc'). `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 4

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

Accepted Answer

'No file found'. 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 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. 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

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

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

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 9

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

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

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 12

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:. 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 13

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

Accepted Answer

KeyboardInterrupt inherits from BaseException.. `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 14

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

Question 15

What will be printed?

Accepted Answer

None. None. This question likely tests that Python functions return None by default when no explicit return statement is present, and printing that value yields None. Therefore, option D is correct.

Answer

-1

Answer

0

Answer

An exception is raised.