PCAP Object-Oriented Programming Practice Test 9 — 15 Questions

Question 1

A junior developer writes a class 'Logger' that should only ever have one instance (singleton). They attempt to implement it by overriding __new__ to always return the same instance. However, when multiple threads attempt to create a Logger, they sometimes get different instances. Which modification will make the singleton thread-safe?

Accepted Answer

Use a lock (threading.Lock) in __new__ to serialize access. Option A is correct because the race condition occurs when multiple threads simultaneously check `cls._instance` and find it `None`, then both proceed to create a new instance. Wrapping the creation logic inside a `threading.Lock` in `__new__` ensures that only one thread can execute the critical section at a time, guaranteeing that only one instance is ever created.

Answer

Use a class method get_instance() that checks a class variable and creates the instance if needed, and call that from __init__

Answer

Use a metaclass that overrides __call__ to return the singleton

Answer

Override __init__ to check if the instance was already initialized and if so, skip initialization

Question 2

Which of the following statements about class inheritance in Python are true? (Choose two.)

Accepted Answer

Abstract base classes can be defined using the ABC module.. Option B is correct because Python's `abc` module (Abstract Base Classes) allows you to define abstract base classes by inheriting from `ABC` and using the `@abstractmethod` decorator. This enforces that subclasses must implement the abstract methods, providing a formal interface contract.

Answer

A class can inherit from only one base class.

Answer

A child class can override any method from its parent class, but only if the method is declared as virtual.

Answer

The super() function is used to call a method from a sibling class.

Question 3

Which three statements about the Method Resolution Order (MRO) in Python are true? (Choose three.)

Accepted Answer

The MRO can be viewed using the __mro__ attribute.. Option A is correct because every Python class has an `__mro__` attribute that returns a tuple of classes in the order they are searched for methods and attributes. This attribute is automatically generated by the C3 linearization algorithm and provides a clear, inspectable view of the resolution order.

Answer

The MRO is only used for methods, not attributes.

Answer

The MRO can be changed by modifying the class hierarchy at runtime.

Question 4

A developer is building a simulation of different types of vehicles. They have a base class Vehicle with an attribute speed initialized in __init__. They also have a subclass Car that inherits from Vehicle and adds an attribute fuel_type. The developer wants to ensure that every time a Car object is created, it also initializes the speed attribute from the Vehicle class. Which approach should the developer use?

Accepted Answer

In Car.__init__, call Vehicle.__init__(self) manually.. Option B is correct because in Python, when a subclass overrides __init__, the parent class's __init__ is not automatically called. To ensure the speed attribute from Vehicle is initialized, the developer must explicitly call Vehicle.__init__(self) inside Car.__init__. This is a fundamental requirement of Python's inheritance mechanism for proper initialization of inherited attributes.

Answer

Override the __new__ method of Vehicle.

Answer

Use the @staticmethod decorator for initialization.

Answer

In Car.__init__, define speed directly without calling parent's __init__.

Question 5

A junior developer wrote a class representing a bank account with a private attribute balance. They used double underscore prefix (__balance) to make it private. However, in a test script, they are still able to access the attribute using the mangled name _Account__balance. The developer is confused about why encapsulation is not enforced. Which statement best explains this behavior?

Accepted Answer

Python's name mangling is only a convention and does not prevent access.. Option B is correct because Python's name mangling (triggered by a double underscore prefix) is not a security mechanism but a syntactic transformation that renames the attribute to _ClassName__attribute. This prevents accidental name clashes in subclasses but does not enforce true encapsulation; the attribute can still be accessed via the mangled name from outside the class. The developer's confusion stems from mistaking name mangling for a privacy guarantee, which Python intentionally does not provide.

Answer

The double underscore prefix actually makes the attribute completely inaccessible from outside the class.

Answer

The developer forgot to use the @property decorator.

Answer

The test script must have used a different class attribute name.

Question 6

A team is developing a data processing pipeline where each step is a class that implements a common interface. They have defined an abstract base class DataProcessor with an abstract method process(data). Several concrete subclasses implement process. Now they need to add a new step that logs the data before processing. They want to reuse the existing processing logic without modifying the original classes. Which design pattern should they apply?

Accepted Answer

Decorator pattern by creating a LoggingProcessor subclass that wraps another processor and calls its process method after logging.. The Decorator pattern allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. By creating a LoggingProcessor that wraps an existing DataProcessor and delegates to its process method after logging, the team reuses the original processing logic without modifying the existing classes, adhering to the Open/Closed Principle.

Answer

Factory pattern to instantiate processors dynamically.

Answer

Singleton pattern to ensure only one logger exists.

Answer

Observer pattern to notify loggers of data changes.

Question 7

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.. Option A is correct because 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 8

A developer is implementing a caching system where object instances should be reused if they have the same set of initialization parameters. They want to control object creation so that calling MyClass(param1, param2) returns the same instance if it has been created before, otherwise creates a new one. They are considering overriding __new__ to implement this caching. However, they also need to ensure that __init__ is not called again for cached instances. What is the correct way to achieve this?

Accepted Answer

Use a class method as an alternative constructor and store instances in a class-level dictionary.. Option B is correct because using a class method as an alternative constructor allows the developer to control instance creation and reuse without interfering with Python's normal object creation protocol. By storing instances in a class-level dictionary keyed by the initialization parameters, the class method can return a cached instance if it exists, or create a new one via the normal constructor (which calls __new__ and __init__). This approach cleanly avoids calling __init__ on cached instances, since the cached object is simply returned directly without invoking the constructor again.

Answer

Override __new__ to return a cached instance, and override __init__ to do nothing if already initialized.

Answer

Override __call__ on the class metaclass.

Answer

Override __new__ to return a cached instance if exists, and skip __init__ by checking if the instance is from cache.

Question 9

A developer is working on a class hierarchy for geometric shapes. They have a base class Shape with an abstract method area(). They also have a mixin class Drawable that provides a method draw(). They want to create a class Rectangle that inherits from both Shape and Drawable. However, they encounter a TypeError when trying to instantiate Rectangle because the abstract method area() is not implemented. Which action should they take to resolve this?

Accepted Answer

Implement the area() method in Rectangle.. Option B is correct because the abstract method area() declared in the Shape base class must be implemented in any concrete subclass. In Python, a class that inherits from an ABC (Abstract Base Class) with an abstract method cannot be instantiated until that method is overridden. By providing an implementation of area() in Rectangle, the class becomes concrete and can be instantiated without raising a TypeError.

Answer

Change the inheritance order to Drawable first, then Shape.

Answer

Use a class decorator @abstractmethod for Rectangle.

Answer

Remove the abstract method from Shape by removing the @abstractmethod decorator.

Question 10

An application uses a heavy-weight class DatabaseConnection that establishes a network connection upon instantiation. The class is used in multiple places, and the developer wants to ensure that only one instance of DatabaseConnection exists throughout the application. They implement a Singleton pattern using a class attribute _instance and a class method get_instance(). However, they notice that the network connection is being established multiple times. After debugging, they find that the singleton is not being enforced because the __init__ method is called every time the class is instantiated, even if the same instance is returned. They want to fix this so that the connection is established only once. Which modification should they make?

Accepted Answer

Override __new__ in DatabaseConnection to control instance creation and return the singleton from there, bypassing __init__ on subsequent calls.. Option A is correct because overriding __new__ allows the developer to control instance creation at the lowest level. By checking if the singleton already exists in __new__, they can return the existing instance without calling __init__ again, thus preventing the network connection from being established multiple times. This is the standard Pythonic way to implement a singleton that avoids reinitialization.

Answer

Use the @staticmethod decorator on get_instance.

Answer

Use a global variable instead of a class attribute to store the singleton.

Answer

Move the connection initialization code out of __init__ and into a separate method that is called only once.

Question 11

Which TWO of the following statements about class attributes in Python are true?

Accepted Answer

Class attributes are shared by all instances.. Class attributes are accessible via the class name and are shared across all instances. Options C, D, and E are false because class attributes can be mutable (e.g., lists), modifying via an instance creates an instance attribute if assigned, and they are defined directly in the class body, not inside methods.

Answer

Class attributes are always immutable.

Answer

Class attributes are defined inside methods.

Answer

Modifying a class attribute via an instance modifies it for all instances.

Question 12

Given that MyClass defines __private_attr in __init__, why does this error occur?

Accepted Answer

The attribute name is mangled to _MyClass__private_attr.. Python uses name mangling for double-underscore attributes: __private_attr becomes _MyClass__private_attr when accessed outside the class. The external code tries to access __private_attr directly, which is mangled, causing the attribute error.

Answer

The attribute was not defined in __init__.

Answer

Private attributes cannot be accessed outside the class.

Answer

The attribute is a class attribute not an instance attribute.

Question 13

A team is developing a banking system in Python. They have a base class Account with attributes account_number and balance, and a method __init__(self, account_number, balance) that initializes these attributes. They then create a subclass SavingsAccount that adds an attribute interest_rate. In SavingsAccount's __init__, they assign self.interest_rate = rate but do not call super().__init__. When they instantiate SavingsAccount('12345', 1000, 0.02) and attempt to print(balance), an AttributeError occurs: 'SavingsAccount' object has no attribute 'balance'. What is the most appropriate fix to ensure that the SavingsAccount includes balance and account_number without code duplication?

Accepted Answer

Call super().__init__(account_number, balance) as the first line in SavingsAccount.__init__, then assign self.interest_rate = rate.. The fix is to call super().__init__ to reuse the base class initialization and then add the subclass-specific attribute. Option A duplicates code, option C changes the architecture unnecessarily, and option D removes necessary initialization.

Answer

Remove the __init__ method from SavingsAccount entirely and rely on the default __init__ from Account.

Answer

Manually assign self.account_number and self.balance in SavingsAccount.__init__ before assigning interest_rate.

Answer

Define balance as a class attribute in Account with a default value and remove it from __init__.

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

4. The __add__ method adds the two values and adds 1, so 1+2+1=4.

Answer

3

Answer

Error

Answer

A object

Question 15

Refer to the exhibit. What is the output?

Accepted Answer

10. Base.method returns 3*2=6, Derived.method adds 4, so 10.

Answer

7

Answer

Error

Answer

14