PCAP Practice Test 25 — 15 Questions

Question 1

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 2

A programmer is writing a script to generate SQL queries safely. They need to escape single quotes in user-provided strings to prevent injection. Which approach is most robust?

Accepted Answer

s.replace("'", "''"). In SQL, single quotes are escaped by doubling them (''), not by using backslashes. This is the standard escape mechanism defined by the SQL standard (ISO/IEC 9075) and is supported by databases like PostgreSQL, SQLite, and Oracle. Using `s.replace("'", "''")` ensures that a single quote in user input becomes two single quotes in the SQL string, preventing injection while preserving the literal quote.

Answer

s.replace("\'", "'")

Answer

s.replace("'", "\'")

Answer

s.strip("'")

Question 3

Which TWO statements about the __init__.py file in a Python package are true?

Accepted Answer

It can define the __all__ list to control what is exported with 'from package import *'.. The `__all__` list in `__init__.py` explicitly defines the public API of a package, controlling which names are exported when a client uses `from package import *`. This is a standard Python mechanism to prevent unintended internal modules from being exposed.

Answer

It must contain at least one import statement to be valid.

Answer

It is mandatory for all packages, including namespace packages.

Answer

It prevents submodules from being imported directly.

Question 4

What is the output of `print('-'.join(['a', 'b', 'c']))`?

Accepted Answer

a-b-c. The `join()` method in Python concatenates the elements of an iterable (here, a list of strings) into a single string, using the string on which it is called as the separator. In this case, `'-'.join(['a', 'b', 'c'])` inserts a hyphen between each element, producing the string `'a-b-c'`. The `print()` function then outputs that string without quotes.

Answer

['a', '-', 'b', '-', 'c']

Answer

('a', '-', 'b', '-', 'c')

Answer

a,b,c

Question 5

An application uses a class to represent a configuration object that reads settings from a file. The class has a class attribute config_cache that holds a dictionary of loaded configurations to avoid repeated file reads. However, the developer notices that when they modify the dictionary for one instance, it affects all instances. They want to ensure that each instance has its own copy of the configuration data upon initialization. Which change should they make?

Accepted Answer

Move the dictionary initialization into the __init__ method so each instance creates its own dictionary.. Moving the dictionary initialization into the __init__ method ensures that each instance gets its own separate dictionary object. Class attributes are shared across all instances, so modifying the dictionary via one instance changes it for all. By assigning `self.config_cache = {}` inside __init__, each instance creates a new, independent dictionary upon instantiation, solving the shared-state problem.

Answer

Use a @staticmethod to return a new dictionary each time.

Answer

Keep the class attribute but use a deep copy in __init__ before modifying.

Answer

Define the dictionary inside a class method.

Question 6

Which THREE of the following are true about the `with` statement for file handling?

Accepted Answer

It uses the __enter__ and __exit__ methods of the file object.. The `with` statement relies on the context management protocol, which requires the object to implement the `__enter__` and `__exit__` methods. When a file object is used with `with`, its `__enter__` method returns the file object itself, and its `__exit__` method is called upon block exit to handle cleanup, such as closing the file.

Answer

It can only be used with files.

Answer

It can only handle one file at a time.

Question 7

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 8

Which TWO statements about namespace packages are true?

Accepted Answer

They are supported in Python 3.3 and later.. Namespace packages were introduced in Python 3.3 via PEP 420. They allow a package to be split across multiple directories on sys.path without requiring an __init__.py file, enabling logical grouping of subpackages from different locations.

Answer

They are automatically created when a directory containing .py files is added to sys.path.

Answer

They can only contain __init__.py files.

Answer

They require an __init__.py file.

Question 9

A team is implementing a shape hierarchy with a base class `Shape` that should have an `area()` method. They want to ensure that every subclass must provide its own implementation of `area()`. Which approach should they use?

Accepted Answer

Use `@abstractmethod` from the `abc` module to declare `area()` as abstract.. The `abc` module provides the `ABCMeta` metaclass and the `@abstractmethod` decorator, which together enforce that any concrete subclass must override the abstract method. If a subclass fails to implement `area()`, Python raises a `TypeError` at instantiation time, ensuring the design contract is upheld. This is the standard Pythonic way to define abstract base classes and enforce method implementation in subclasses.

Answer

Define `area()` in `Shape` and have it raise `NotImplementedError`.

Answer

Use a class method that must be overridden.

Answer

Define `area()` as a property that raises an error.

Question 10

You are a developer for an e-commerce platform. The system receives product descriptions from suppliers in various formats. One supplier sends descriptions with inconsistent capitalization, extra whitespace, and occasional leading/trailing punctuation. Your task is to write a function that normalizes these descriptions: convert to lowercase, remove leading/trailing whitespace and punctuation (.,!?;:), and replace multiple spaces with a single space. The function should return the cleaned string. Which implementation correctly performs all these steps?

Accepted Answer

def normalize(s): import re; s = s.strip(); s = s.strip('.,!?;:'); s = s.lower(); s = re.sub(r'\s+', ' ', s); return s. It performs all required steps in the correct order: it first strips leading/trailing whitespace with `strip()`, then removes leading/trailing punctuation using `strip('.,!?;:')`, converts to lowercase with `lower()`, and finally replaces multiple spaces with a single space using `re.sub(r'\s+', ' ', s)`. This ensures that punctuation is removed only from the edges after whitespace is handled, and internal whitespace is normalized last.

Answer

def normalize(s): return ' '.join(s.lower().split())

Answer

def normalize(s): return s.lower().strip('.,!?;: ')

Answer

def normalize(s): return s.strip().lower()

Question 11

A developer writes a function to reverse a string: def reverse_str(s): return s[::-1]. Which of the following statements about this function is true?

Accepted Answer

It returns a new reversed string. The slice operation `s[::-1]` creates a new string that is the reverse of the original. Strings in Python are immutable, so any operation that appears to modify a string actually returns a new string object. The original string `s` remains unchanged.

Answer

It only works for strings with even length

Answer

It modifies the original string

Answer

It raises an error if s is empty

Question 12

A programmer has a string 'apple,banana,orange' and wants to get a list ['apple', 'banana', 'orange']. Which method should be used?

Accepted Answer

s.split(','). `s.split(',')` splits the string `'apple,banana,orange'` at each comma delimiter, returning a list of substrings: `['apple', 'banana', 'orange']`. This method is designed to break a string into a list based on a specified separator, making it the exact tool for this task.

Answer

s.splitlines()

Answer

s.partition(',')

Answer

s.join(',')

Question 13

Which THREE are valid ways to create a multiline string in Python?

Accepted Answer

s = ('Line1
' 'Line2'). Options A, B, and C are all valid ways to create a multiline string in Python. Option A uses implicit string concatenation within parentheses; the `
` escape sequence inserts a newline, resulting in a multiline string. Option B uses triple double quotes to span multiple lines physically, preserving line breaks. Option C uses triple single quotes, which work identically to triple double quotes for multiline strings. Option D uses a backslash for line continuation, which does not insert a newline into the string—it just continues the literal on the next line, so the result is a single-line string without a newline. Option E causes a syntax error because a single-quoted string literal cannot span multiple lines without a continuation character.

Answer

s = "Line1\
Line2"

Answer

s = 'Line1
Line2'

Question 14

Which THREE of the following are valid escape sequences in Python strings?

Accepted Answer

. 	 is the standard escape sequence for a horizontal tab character in Python strings. Escape sequences in Python begin with a backslash followed by a specific character, and 	 is defined in the Python language specification (similar to C) to represent the ASCII tab character (0x09).

Answer

\g

Answer

\h

Question 15

A script uses `with open('data.bin', 'rb') as f:` to read binary data. Within the block, which method should be used to read exactly 4 bytes?

Accepted Answer

f.read(4). The `read(n)` method reads exactly `n` bytes from the file object when the file is opened in binary mode (`'rb'`). Since the question specifies reading exactly 4 bytes, `f.read(4)` is the correct and direct approach. This method returns a bytes object of up to `n` bytes, but if the file has at least 4 bytes remaining, it will return exactly 4.

Answer

f.seek(4)

Answer

f.readline()

Answer

f.read()