PCAP Object-Oriented Programming Practice Test 2 — 15 Questions

Question 1

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. Option D is correct because 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 2

An engineer is debugging an application that uses inheritance. The base class 'Vehicle' defines a method 'start()' that prints 'Vehicle started'. The subclass 'Car' overrides 'start()' to print 'Car started'. The code contains a function that accepts a Vehicle object and calls 'start()'. What is the output if a Car object is passed?

Accepted Answer

'Car started'. When a Car object is passed to a function expecting a Vehicle reference, Python uses dynamic dispatch (late binding) to call the overridden `start()` method defined in the Car class. Since the actual runtime type is Car, the overridden version executes, printing 'Car started'. This is a fundamental principle of polymorphism in Python.

Answer

'Car started Vehicle started'

Answer

'Vehicle started'

Answer

AttributeError

Question 3

A Python developer is implementing a class that should behave like a sequence and support indexing. Which pair of special methods must be defined to achieve this?

Accepted Answer

__getitem__ and __len__. To make a class behave like a sequence and support indexing (e.g., obj[0]), Python requires the __getitem__ method to retrieve items by key. Additionally, the __len__ method is needed to define the length of the sequence, which is used by built-in functions like len() and is part of the sequence protocol. Together, these two methods satisfy the minimal requirements for a sequence-like object that supports indexing.

Answer

__getitem__ and __contains__

Answer

__setitem__ and __delitem__

Answer

__iter__ and __next__

Question 4

During code review, a team member wrote: 'class Dog(Animal): pass'. The Animal class has an __init__ method that requires a 'name' parameter. When instantiating Dog, what should be done to properly initialize the inherited attributes?

Accepted Answer

Define __init__ in Dog that calls super().__init__(name). Option D is correct because in Python, when a subclass like Dog inherits from a superclass like Animal, the __init__ method is not automatically called unless explicitly invoked. Since Animal's __init__ requires a 'name' parameter, Dog must define its own __init__ and call super().__init__(name) to ensure the inherited attributes are properly initialized. This follows Python's method resolution order (MRO) and is the standard pattern for cooperative multiple inheritance.

Answer

Define a new __init__ in Dog that does not call super

Answer

Dog will automatically inherit the __init__ method

Answer

Use a decorator to initialize

Question 5

A programmer writes a class with a static method using @staticmethod. What is the primary purpose of using a static method instead of a class method or instance method?

Accepted Answer

To define a method that does not depend on class or instance state and behaves like a regular function but is namespaced inside the class. Option B is correct because a static method in Python, decorated with @staticmethod, does not receive an implicit first argument (neither self nor cls). This means it cannot access or modify class or instance state; it behaves exactly like a regular function but is organized within the class's namespace for logical grouping. The primary purpose is to encapsulate utility functions that are related to the class but do not depend on its data.

Answer

To access class variables without creating an instance

Answer

To allow the method to be overridden in subclasses

Answer

To enforce that the method cannot be called from an instance

Question 6

Consider the following code snippet: 'class A: pass; class B(A): pass; class C(A): pass; class D(B, C): pass'. What is the Method Resolution Order (MRO) for class D according to the C3 linearization algorithm used by Python?

Accepted Answer

D, B, C, A, object. The C3 linearization algorithm merges the linearizations of D's parents (B and C) with their parent list, respecting the local precedence order and monotonicity. For class D(B, C), the MRO is computed as D + merge(L(B), L(C), [B, C]), where L(B) = B, A, object and L(C) = C, A, object. The merge yields D, B, C, A, object, which is the correct MRO.

Answer

D, B, A, C, object

Answer

D, B, C, A

Answer

D, B, A, object, C

Question 7

A developer needs to create a class that cannot be instantiated directly but serves as a base for other classes. Which approach should be used?

Accepted Answer

Define __init__ that raises NotImplementedError. Option A is correct because raising `NotImplementedError` in the `__init__` method prevents direct instantiation of the class while still allowing subclasses to override `__init__` and be instantiated. This is a common Python pattern for creating abstract base classes without using the `abc` module, though it does not enforce abstraction at the method level.

Answer

Define the class using the ABCMeta metaclass and decorate methods with @abstractmethod

Answer

Use a naming convention like _BaseClass

Answer

Define __new__ to return None

Question 8

Which TWO of the following are valid ways to define a class attribute (as opposed to an instance attribute) in Python?

Accepted Answer

class MyClass: attr = 5. Option D is correct because defining `attr = 5` directly inside the class body, but outside any method, creates a class attribute that is shared by all instances. This is the standard Python syntax for class-level data.

Answer

obj.attr = 5 on an instance

Answer

class MyClass: def method(self): pass

Answer

class MyClass: def __init__(self): self.attr = 5

Question 9

Refer to the exhibit. Which THREE statements about the class hierarchy are correct?

Accepted Answer

Calling D().method() returns 'B'. Option B is correct because when `D().method()` is called, Python's MRO (Method Resolution Order) for class D is `['D', 'B', 'C', 'A', 'object']`. Since class D does not define `method`, Python looks up the MRO and finds `method` first in class B. The `return 'B'` in B's `method` is executed, so the call returns 'B'.

Answer

D does not have a method named 'method'

Answer

The super() call in B would call C.method

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

2
2
2. Option B is correct because the code defines a class `A` with a class variable `x = 2`, and a class `B` that inherits from `A`. The `display` method prints `self.x`, which first looks up the instance attribute `x`; since no instance attribute is set, it falls back to the class variable `x = 2` from class `A`. The loop creates three instances of `B` and calls `display` on each, so each prints `2` on a separate line, resulting in the output 2, 2, 2.

Answer

2
0
0

Answer

2
1
1

Answer

0
2
2

Question 11

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

Accepted Answer

It raises an AttributeError. The code attempts to call a method or access an attribute that does not exist on the object. In Python, when you try to access an attribute or method that is not defined on an object, an AttributeError is raised. Option C is correct because the exhibit shows an attempt to call a non-existent method or attribute on an instance, which triggers AttributeError.

Answer

It prints None

Answer

It raises a TypeError

Answer

It prints 10

Question 12

You are working on a legacy system that processes financial transactions. The system uses a class hierarchy: Transaction (base), Deposit, Withdrawal, Transfer. Each subclass overrides a method 'process()' to handle its specific logic. The code often runs in a multi-threaded environment and you notice intermittent errors where a transaction is processed twice. The logging shows that the same transaction object is being passed to the process method multiple times. The transaction objects are created from a factory function that caches recently used transactions. The errors seem to occur when two threads call the factory at the same time with the same parameters. After investigating, you find that the factory uses a class-level dictionary to cache objects. Which of the following is the most appropriate solution to prevent double processing?

Accepted Answer

Make the process() method idempotent by checking if the transaction has already been applied to the account (e.g., check balance changes). Option D is correct because the core issue is that the same transaction object can be processed multiple times in a multi-threaded environment, even if the factory is fixed. Making process() idempotent by checking whether the transaction has already been applied (e.g., verifying account balance changes) ensures that repeated calls with the same object do not cause duplicate financial effects, directly addressing the symptom of double processing regardless of how the object is cached or retrieved.

Answer

Add a lock around the cache lookup and creation in the factory function

Answer

Add a flag to each transaction object to indicate if it has been processed, and check it at the start of process()

Answer

Remove the caching mechanism from the factory function to ensure new objects are always created

Question 13

Drag and drop the steps to define and call a function with default arguments in Python into the correct order.

Question 14

Drag and drop the steps to create a Python package with subpackages into the correct order.

Question 15

Match each Python operator to its precedence level (1=highest).