PCAP Object-Oriented Programming Practice Test 10 — 15 Questions

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

In Car.__init__, call Vehicle.__init__(self) manually.. 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 2

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

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 4

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 5

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

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 defined directly in the class body and are shared across all instances of that class. When you access a class attribute via any instance, Python looks up the attribute in the class's __dict__ if it is not shadowed by an instance attribute, ensuring all instances see the same value unless explicitly overridden.

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 7

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 attributes with double underscores (__) to avoid accidental overriding in subclasses. When you define __private_attr inside __init__, Python internally renames it to _MyClass__private_attr. Attempting to access obj.__private_attr from outside the class fails because that mangled name is not recognized, leading to an AttributeError.

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 8

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.. In Python, the subclass SavingsAccount overrides __init__ but never invokes the parent's initializer, so account_number and balance are never set on the instance. Calling super().__init__(account_number, balance) as the first line of SavingsAccount.__init__ runs Account's initializer, which assigns those attributes, and then the subclass can safely set self.interest_rate = rate. This is the canonical cooperative-initialization pattern and avoids duplicating the parent's assignment logic.

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 9

Refer to the exhibit. What is the output of the last line?

Accepted Answer

{'name': 'John', '_Employee__salary': 50000}. Python uses name mangling for attributes starting with double underscores (like `__salary`). When accessed via `vars()`, the mangled name `_Employee__salary` is shown, not the original `__salary`. The `vars()` function returns the `__dict__` of the object, which contains the mangled attribute name.

Answer

{'name': 'John'}

Answer

AttributeError: 'Employee' object has no attribute '__salary'

Answer

{'name': 'John', '__salary': 50000}

Question 10

Refer to the exhibit. What happens when the last command is executed?

Accepted Answer

It raises TypeError: Can't instantiate abstract class Circle with abstract methods area. The last command attempts to instantiate an abstract class `Circle` that has an abstract method `area` which has not been implemented. In Python, abstract classes defined with `ABC` and decorated with `@abstractmethod` cannot be instantiated directly; attempting to do so raises `TypeError` with the message 'Can't instantiate abstract class Circle with abstract methods area'.

Answer

It creates a Circle object successfully

Answer

It prints nothing and exits with code 0

Answer

It raises AttributeError: 'Circle' object has no attribute 'area'

Question 11

A class `Circle` has a class attribute `pi = 3.14`. An instance `c = Circle()` sets `c.pi = 3.14159`. What is the value of `Circle.pi` after this assignment?

Accepted Answer

3.14. In Python, attribute assignment on an instance always creates or modifies an instance attribute, even if a class attribute with the same name exists. The class attribute is only modified when assigned via the class itself, such as `Circle.pi = value`. Here, `c.pi = 3.14159` adds an instance attribute to `c`, leaving `Circle.pi` at 3.14.

Answer

An AttributeError is raised because class attributes cannot be shadowed.

Answer

The value is undefined because class attributes are immutable.

Answer

3.14159

Question 12

A developer writes a class `Vector` and wants `v1 + v2` to return a brand-new `Vector`, while `v1 += v2` should mutate `v1` in place and return it. Which pair of special methods achieves this behaviour?

Accepted Answer

`__add__` returning a new `Vector`, and `__iadd__` mutating `self` and returning `self`.. Defining `__add__` for the binary plus operator and `__iadd__` for augmented assignment is the idiomatic way to separate non-mutating and in-place semantics. The binary method returns a fresh instance so operands are left untouched, while the in-place method mutates the receiver and returns it so the same object identity is preserved after `+=`. Reflected methods such as `__radd__` serve a different purpose and cannot substitute for either.

Answer

`__add__` returning a new `Vector`, and `__radd__` mutating `self` and returning `self`.

Answer

`__add__` mutating `self` and returning `self`, and `__radd__` returning a new `Vector`.

Answer

`__iadd__` returning a new `Vector`, and `__add__` mutating `self` and returning `None`.

Question 13

A developer writes a class `Logger` with a method `log(self, message)`. They want to ensure that when `Logger` is subclassed, any override of `log` must call the parent's `log` method. Which technique best enforces this requirement in Python?

Accepted Answer

There is no built-in Python mechanism to enforce that an override calls the parent method; it must be handled by convention and documentation.. Python's philosophy emphasizes flexibility and developer responsibility. There is no language-level construct that forces a subclass to call `super().log()`. Techniques like abstract methods ensure implementation but not invocation of the parent. Metaclasses or descriptors could be used to add checks, but they are not built-in and are overly complex. The correct answer recognizes that enforcement is not a built-in feature.

Answer

Decorate the parent's `log` method with `@abstractmethod`.

Answer

Use a metaclass that wraps the `log` method to check if `super().log` was called.

Answer

Define `log` in the parent class to raise `NotImplementedError` and document that subclasses must call `super().log()`.

Question 14

A team wants a `Logger` class that can be used both as `Logger.log('msg')` on the class itself and as `logger.log('msg')` on an instance, with identical behaviour and no access to instance state. Which decorator should be applied to `log`?

Accepted Answer

`@staticmethod`. A static method is bound to neither the instance nor the class, so it can be invoked through either the class name or an instance with the same argument list and the same result. Because the logging behaviour does not depend on instance or class state, the missing implicit parameter is not a limitation. A class method would work but needlessly injects the class as an argument, and the other decorators change attribute semantics rather than call binding.

Answer

`@classmethod`

Answer

`@abstractmethod`

Answer

`@property`

Question 15

A class `Vector` defines `__add__` to return a new `Vector`. A developer writes `v1 = Vector(1,2); v2 = Vector(3,4); v3 = v1 + v2`. What is the type of `v3`?

Accepted Answer

`Vector`. Operator overloading in Python allows classes to define behavior for operators like `+`. The `__add__` method is called on the left operand, and its return value becomes the result of the expression. Since the `Vector` class implements `__add__` to return a new `Vector`, `v3` is a `Vector` instance.

Answer

`None`

Answer

`int`

Answer

`tuple`