PCAP Practice Test 23 — 15 Questions

Question 1

Which TWO of the following are valid ways to define a property in a Python class? (Select exactly 2.)

Accepted Answer

Use `property(getter, setter)` as a class variable.. `property(getter, setter)` is a built-in function that returns a property object, which can be assigned as a class variable to define a managed attribute. Option E is correct because the `@property` decorator is the standard, concise way to define a read-only property by decorating a method that acts as the getter.

Answer

Define a method named `property` inside the class.

Answer

Override `__getattribute__` and check the attribute name.

Answer

Override `__getattr__` to simulate a property.

Question 2

An application needs to dynamically load a module whose name is provided at runtime (stored in a variable 'mod_name'). Which function from the importlib module should be used?

Accepted Answer

importlib.import_module(mod_name). `importlib.import_module(mod_name)` is the standard Python function designed to dynamically import a module given its name as a string at runtime. It returns the module object, allowing the application to load and use modules whose names are not known until execution.

Answer

importlib.reload(mod_name)

Answer

importlib.load_module(mod_name)

Answer

importlib.import(mod_name)

Question 3

Which TWO of the following string methods return a boolean value (True or False)?

Accepted Answer

str.startswith(). Both `str.startswith()` and `str.isdigit()` return a boolean value (`True` or `False`) because they are designed for conditional checks. `str.startswith()` checks if the string starts with a given prefix, while `str.isdigit()` checks if all characters in the string are digits. In contrast, `str.upper()` returns a new string, `str.split()` returns a list, and `str.find()` returns an integer index. Therefore, options C and D are the correct answers.

Answer

str.upper()

Answer

str.split()

Answer

str.find()

Question 4

A developer wants to ensure that an attribute 'balance' of a BankAccount class cannot be accessed directly from outside the class but can be accessed through a method. Which approach should be used?

Accepted Answer

Declare 'self.__balance' and provide a getter method. Prefixing the attribute with double underscores (`__balance`) triggers Python's name mangling, which renames the attribute to `_BankAccount__balance` at runtime. This prevents direct access from outside the class (e.g., `obj.balance` raises an `AttributeError`), while a getter method (e.g., `get_balance()`) can still retrieve the value. This is the standard Python idiom for achieving 'weak' private encapsulation in OOP.

Answer

Declare 'self.balance' as a class variable

Answer

Declare 'self.balance' and provide a getter method

Answer

Declare 'self._balance' and provide a getter method

Question 5

A class 'MyClass' has a method 'do_something' that uses 'self.__private'. A subclass 'MySubClass' tries to access 'self.__private' and gets an AttributeError. Why?

Accepted Answer

Because name mangling renames the attribute to _MyClass__private, and the subclass implicitly accesses _MySubClass__private. Python's name mangling mechanism renames any attribute prefixed with double underscores (like `__private`) in a class definition to `_ClassName__private`. When `MySubClass` tries to access `self.__private`, Python looks for `_MySubClass__private`, which does not exist, causing an AttributeError. The attribute `_MyClass__private` is still accessible from the subclass, but only via its mangled name.

Answer

Because the attribute is defined as a class attribute, not instance attribute

Answer

Because the subclass overrides the method that uses the attribute

Answer

Because the attribute is private and not inherited

Question 6

A developer needs to check if a filename starts with the prefix 'report_'. Which string method should be used?

Accepted Answer

startswith(). The `startswith()` method is the correct string method in Python to check if a string begins with a specified prefix. It returns `True` if the string starts with the given substring, otherwise `False`, making it the exact tool for checking if a filename starts with 'report_'.

Answer

prefix()

Answer

starts()

Answer

beginwith()

Question 7

A script reads a binary file and decodes it as UTF-8. Some bytes are invalid UTF-8 sequences, causing a `UnicodeDecodeError`. The developer wants to replace invalid bytes with the replacement character U+FFFD. Which approach achieves this?

Accepted Answer

data.decode('utf-8', errors='replace'). The `errors='replace'` parameter in Python's `decode()` method replaces any bytes that cannot be decoded as valid UTF-8 with the Unicode replacement character U+FFFD, which is exactly what the developer wants. This approach ensures the script continues processing without raising a `UnicodeDecodeError` while preserving the overall structure of the data.

Answer

data.decode('utf-8', errors='strict')

Answer

data.decode('utf-8', errors='surrogateescape')

Answer

data.decode('utf-8', errors='ignore')

Question 8

A parent class defines a method `move()`. A child class overrides `move()` but also needs to call the parent's version inside it. Which syntax allows that?

Accepted Answer

`super().move()`. `super().move()` is the Python syntax for calling the parent class's `move()` method from within the child class's overridden version. The `super()` function returns a proxy object that delegates method calls to the parent class, following the MRO (Method Resolution Order). This allows the child to extend the parent's behavior without hardcoding the parent class name.

Answer

`self.move()`

Answer

`Parent.move()`

Answer

`ParentClass.move(self)`

Question 9

A developer runs the following code in a script that is not part of a package:
import sys
sys.path.insert(0, '/custom/path')
import mymodule
print(mymodule.__name__)
What is the output if 'mymodule' is found at '/custom/path/mymodule.py'?

Accepted Answer

mymodule. When a module is imported, Python assigns the `__name__` attribute to the module's name as a string (e.g., 'mymodule'), not the filename with extension. Since the script is not part of a package and the module is found at a custom path, `mymodule.__name__` is simply 'mymodule'.

Answer

mymodule.py

Answer

__main__

Answer

/custom/path/mymodule.py

Question 10

A package named 'utilities' contains a submodule 'strings'. Which import statement allows the use of the function 'reverse' defined in utilities.strings as reverse() without needing to prefix it?

Accepted Answer

from utilities.strings import reverse. It directly imports the `reverse` function from the `utilities.strings` submodule into the current namespace, allowing it to be called as `reverse()` without any prefix. This is the only option that imports the specific function rather than the module or package.

Answer

import utilities.strings

Answer

from utilities import strings

Answer

from utilities import *

Question 11

A developer wants to replace all vowels in a string with their corresponding uppercase letters. They wrote: `s = 'hello world'`; `vowels = 'aeiou'`; `trans = str.maketrans(vowels, vowels.upper())`; `result = s.translate(trans)`. What is the value of `result`?

Accepted Answer

'hEllO wOrld'. The `str.maketrans(vowels, vowels.upper())` creates a translation table mapping each lowercase vowel to its uppercase equivalent. The `translate()` method then replaces only the vowels in the original string, leaving all other characters unchanged. In 'hello world', the vowels 'e', 'o', 'o' become 'E', 'O', 'O', resulting in 'hEllO wOrld' — note that the first 'h' and 'w' remain lowercase because they are consonants.

Answer

'HEllO WOrld'

Answer

'H@ll@ W@rld'

Answer

'hello world'

Question 12

Which TWO string methods are used to determine if a string begins or ends with a specified prefix or suffix? (Choose two.)

Accepted Answer

startswith(). The `startswith()` method returns `True` if a string begins with the specified prefix, and `endswith()` returns `True` if a string ends with the specified suffix. Both methods accept a string or a tuple of strings to check against, making them the correct choices for determining prefix or suffix presence.

Answer

count()

Answer

find()

Answer

index()

Question 13

Refer to the exhibit. What will be the output when the code is executed?

Accepted Answer

2. The code defines a class `MyClass` with a class attribute `x = 1`. The `__init__` method sets an instance attribute `self.x = 2`. When `obj.x` is accessed, Python first looks for an instance attribute, finding `self.x = 2`, so it prints `2`. Option D is correct because instance attributes shadow class attributes.

Answer

AttributeError

Answer

None

Answer

1

Question 14

A developer creates classes `A`, `B(A)`, `C(A)`, and `D(B, C)`. When calling a method from `D` that is defined in `A`, which class's version is used according to Python's MRO?

Accepted Answer

The method from A, found through B then C.. Python's Method Resolution Order (MRO) for class `D(B, C)` follows the C3 linearization algorithm, which ensures a depth-first left-to-right search while preserving monotonicity. For `D(B, C)`, the MRO is `D -> B -> C -> A`, so a method defined in `A` that is not overridden in `B` or `C` will be found via `B` first, then `C`, and finally `A`. Option D correctly states that the method from `A` is used, found through `B` then `C`, which matches the actual resolution path.

Answer

The method from B, because it is the first parent.

Answer

The method from C, because it appears after B.

Answer

The method from A, but only if B and C do not override it.

Question 15

A team is using inheritance but wants to prevent a method from being overridden in subclasses. What Python feature can enforce this?

Accepted Answer

Use a @final decorator.. The `@final` decorator, introduced in Python 3.8 via the `typing` module, is specifically intended to mark a method as final, signaling that it should not be overridden in subclasses. While Python does not enforce this at runtime, type checkers (e.g., mypy) can flag violations, making it the correct feature for preventing overriding in a design intent context. Option A, the double underscore prefix, only triggers name mangling (`_ClassName__method`), which is meant to avoid accidental collisions but does not prevent a subclass from defining a method with the mangled name directly, thus it does not enforce non-overridability.

Answer

Use a private method with double underscore prefix (__method).

Answer

Use @staticmethod.

Answer

Use @abstractmethod.