PCAP Practice Test 29 — 15 Questions

Question 1

A developer is working on a data pipeline that processes files from untrusted sources. The pipeline should catch and log any exception, but also ensure that sensitive information from the exception (e.g., file paths) is not exposed to end users. Which approach balances security and debugging?

Accepted Answer

Catch the exception, log the full traceback, then raise a custom generic exception.. Option C is correct because it balances security and debugging: the full traceback is logged for developers (preserving debugging details like file paths), while a custom generic exception is raised to end users, preventing sensitive information from being exposed. This approach follows the principle of least privilege for error handling, ensuring that internal details are not leaked to untrusted sources.

Answer

Catch the exception and re-raise the same exception.

Answer

Catch the exception, log it, and suppress it silently.

Answer

Catch the exception and print it to the console.

Question 2

Which TWO statements about exception handling in Python are correct? (Select exactly 2.)

Accepted Answer

A single except clause can catch multiple exception types by passing a tuple of exceptions.. Option A is correct because Python's except clause accepts a tuple of exception types, allowing a single handler to catch multiple exception types. For example, `except (ValueError, TypeError):` will catch either exception, which is a concise way to handle related errors without duplicating code.

Answer

The order of except clauses does not matter because only one will match.

Answer

An else block can be used without any except blocks in a try statement.

Answer

The else block in a try statement executes only if an exception was raised.

Question 3

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

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 B is correct because when the IndexError handler is removed, the exception propagates to the next matching except clause. Since IndexError is a subclass of LookupError, the LookupError handler will catch the raised IndexError. This demonstrates the hierarchical nature of exception handling in Python, where a more general exception class can catch exceptions of its subclasses.

Answer

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

Question 7

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 8

Refer to the exhibit. A developer ran the script and saw the above traceback. The intended behavior was to load a JSON configuration file, and if the file is missing, create a default config. What is the most likely root cause of the second exception (NameError)?

Accepted Answer

The script did not import the json module.. Option B is correct because the traceback shows a NameError for 'json.loads', which indicates that the name 'json' is not defined in the current namespace. This occurs when the script attempts to call json.loads() without first importing the json module. The intended behavior of loading a JSON configuration file requires the json module to parse the file content, and its absence causes the NameError exception.

Answer

The variable 'f' was not defined due to the FileNotFoundError.

Answer

The config.json file exists but is empty.

Answer

The file was opened in binary mode instead of text mode.

Question 9

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 10

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 11

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 12

What is the output of the following code?

try:
    exec('1/0')
except:
    print('error')
else:
    print('no error')
finally:
    print('done')

Accepted Answer

error done. Option A is correct because the `exec('1/0')` raises a `ZeroDivisionError`, which is caught by the bare `except:` clause, printing 'error'. The `else` clause is skipped because an exception occurred, but the `finally` clause always executes, printing 'done'. Thus the output is 'error' followed by 'done'.

Answer

done error

Answer

error

Answer

done

Question 13

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

Accepted Answer

Using traceback.format_exc(). Option B is correct because `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 14

Refer to the exhibit. A developer is writing a script to read this JSON configuration file. The script should write the logging configuration to a separate file called 'logging.conf'. Which file mode should be used to create the file if it doesn't exist, and overwrite it if it does?

Accepted Answer

'w'. Option D ('w') is correct because the 'w' mode opens a file for writing, truncating it first if it exists, and creating it if it does not. This matches the requirement to overwrite an existing 'logging.conf' file or create a new one if absent.

Answer

'x'

Answer

'r+'

Answer

'a'

Question 15

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'