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

Question 1

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 2

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 3

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 4

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

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 7

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 8

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 9

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 10

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.

Question 11

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 12

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

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 14

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

Accepted Answer

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

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