PCAP Object-Oriented Programming Practice Test 9 — 15 Questions

Question 1

Which THREE of the following are characteristics of Python's special methods (dunder methods)? (Select exactly three.)

Accepted Answer

They enable operator overloading for user-defined classes.. Special methods like `__add__` and `__eq__` allow user-defined classes to redefine the behavior of operators such as `+` and `==`. When Python encounters an operator expression, it looks up the corresponding dunder method on the object's class, enabling operator overloading in a clean, syntactic way.

Answer

Every class automatically has all special methods predefined.

Answer

They must be defined inside the class definition and cannot be added later.

Question 2

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

Accepted Answer

An AttributeError is raised.. When a class defines `__slots__`, it restricts attribute assignment to only those names listed in `__slots__`. Attempting to assign an attribute not in that list (like `city`) raises an `AttributeError` because the instance has no `__dict__` to store dynamic attributes. The `__init__` method does not override this restriction; it simply initializes the allowed slots.

Answer

The attribute 'city' is added dynamically.

Answer

The __slots__ is ignored because __init__ is defined.

Answer

A syntax error occurs.

Question 3

A developer defines a class hierarchy with multiple inheritance: class A, class B(A), class C(A), class D(B,C). The method 'm' is defined only in A. What is the method resolution order for D according to the C3 linearization algorithm?

Accepted Answer

D -> B -> C -> A -> object. B is correct because the C3 linearization algorithm always includes 'object' at the end of the MRO. For class D(B, C), L(D) = D + merge(L(B), L(C), [B, C]). L(B) = B, A, object; L(C) = C, A, object. Merge yields D, B, C, A, object. Options that omit 'object' (like C) are incomplete.

Answer

D -> B -> A -> object

Answer

D -> B -> C -> A

Answer

D -> B -> A -> C

Question 4

A developer wants to implement a read-only property for a class 'Temperature' that returns the temperature in Celsius but prevents external modification. Which code snippet correctly defines such a property?

Accepted Answer

class Temperature: @property
def celsius(self): return self._celsius. It defines a read-only property using the `@property` decorator with only a getter method. Without a setter, any attempt to assign a value to `celsius` will raise an `AttributeError`, making the property read-only. This is the standard Pythonic way to implement a read-only attribute.

Answer

class Temperature: @property
def celsius(self): return self._celsius
@celsius.setter
def celsius(self, val): self._celsius = val

Answer

class Temperature: def __setattr__(self, name, val): if name == 'celsius': raise AttributeError

Answer

class Temperature: def __init__(self, c): self.celsius = c

Question 5

A developer creates a metaclass 'Meta' that modifies class creation by adding a class attribute 'created_by' set to 'Meta'. Which code snippet correctly defines and uses this metaclass?

Accepted Answer

class Meta(type): def __new__(cls, name, bases, dct): dct['created_by']='Meta'; return super().__new__(cls, name, bases, dct). It defines a proper metaclass by subclassing `type` and overriding `__new__`, which is the correct method for modifying the class dictionary before the class is created. The `__new__` method must return the result of `super().__new__(cls, name, bases, dct)` to actually create the class object. Adding `dct['created_by']='Meta'` inside `__new__` ensures the attribute is set during class creation.

Answer

class Meta(type): def __new__(cls, name, bases, dct): dct['created_by']='Meta'

Answer

class Meta(type): def __init__(cls, name, bases, dct): dct['created_by']='Meta'

Answer

def Meta(name, bases, dct): dct['created_by']='Meta'; return type(name, bases, dct)

Question 6

A developer designs a plugin system where each plugin must implement a method 'execute'. Which code snippet correctly enforces that subclasses provide an implementation using the 'abc' module?

Accepted Answer

from abc import ABC, abstractmethod
class Plugin(ABC): @abstractmethod
def execute(self): pass. It uses both `ABC` as the metaclass and `@abstractmethod` decorator to enforce that subclasses must override the `execute` method. Without `ABC`, the `@abstractmethod` decorator has no effect; without `@abstractmethod`, the method is just a regular method that can be inherited without being overridden. This combination ensures that any concrete subclass that does not implement `execute` will raise a `TypeError` at instantiation time.

Answer

from abc import abstractmethod
class Plugin: @abstractmethod
def execute(self): pass

Answer

from abc import ABC
class Plugin(ABC): def execute(self): pass

Answer

class Plugin: def execute(self): raise NotImplementedError

Question 7

A developer wants a class 'LoggedDict' that behaves like a dict but logs all attribute access in the console. Which method override correctly implements this for getting an attribute?

Accepted Answer

def __getattribute__(self, name): print(f'Access {name}'); return super().__getattribute__(name). `__getattribute__` is the universal method called for every attribute access on an object. By overriding it, the developer can log the attribute name before delegating to the superclass implementation via `super().__getattribute__(name)`, which preserves the normal attribute lookup chain. This ensures that all attribute accesses (including those that exist and those that don't) are logged, which is the requirement for 'LoggedDict'.

Answer

def __get__(self, instance, owner): print(f'Access'); return self

Answer

def __getattr__(self, name): print(f'Access {name}'); return self.__dict__[name]

Answer

def __getitem__(self, key): print(f'Access {key}'); return dict.__getitem__(self, key)

Question 8

A developer wants a class 'Point' to have a readable string representation that returns 'Point(x, y)'. Which special method should be overridden?

Accepted Answer

__repr__. The `__repr__` method is designed to return an unambiguous string representation of an object, often used for debugging and development. Overriding `__repr__` to return `'Point(x, y)'` fulfills the requirement for a readable string representation that matches the specified format. This method is called by the `repr()` built-in function and by the interactive interpreter when evaluating an expression.

Answer

__format__

Answer

__str__

Answer

__unicode__

Question 9

Which THREE of the following are true about Python's object-oriented programming features?

Accepted Answer

Python supports multiple inheritance. Python's class hierarchy supports multiple inheritance, allowing a class to inherit from more than one parent class. This is a core feature of Python's object-oriented programming model, implemented via the C3 linearization algorithm (Method Resolution Order, or MRO) to resolve method and attribute lookups unambiguously.

Answer

Python supports method overloading based on argument types

Answer

Python enforces access modifiers like private and protected

Question 10

Which TWO statements about method overriding in Python are correct?

Accepted Answer

The overriding method can call the parent method using super(). The overriding method can call the parent class's version of the method using the built-in `super()` function, which returns a proxy object that delegates method calls to the parent class. This is a fundamental feature of Python's inheritance mechanism, allowing the child method to extend or modify the parent's behavior while still invoking it.

Answer

The overriding method requires explicit use of the @override decorator

Answer

The overriding method must have the exact same parameter list

Answer

Overriding is resolved at compile time

Question 11

A development team is building a real-time chat application using Python. The application uses a class 'ChatRoom' that maintains a list of 'User' objects as active participants. Each User object holds a reference back to its ChatRoom to send messages. Over time, the application runs out of memory. Profiling reveals that User objects are not being garbage collected even after users disconnect. The team suspects circular references. Which solution would effectively resolve the memory leak without breaking the functionality?

Accepted Answer

Use weakref.WeakSet for the participants list in ChatRoom, so that when a User is no longer referenced elsewhere, it is automatically removed. Using a `weakref.WeakSet` for the participants list in `ChatRoom` means the `ChatRoom` holds only weak references to `User` objects. When a user disconnects and all external references to that `User` are removed, the `User` object becomes unreachable and can be garbage collected, even though the `User` still holds a strong reference back to the `ChatRoom`. This breaks the circular reference without requiring manual intervention or altering the `User`-to-`ChatRoom` relationship.

Answer

Increase the Python heap size using PYTHON_MALLOC_DEBUG to avoid memory issues

Answer

Store the ChatRoom reference in User using a weakref.ref, so that the cycle is broken

Answer

Manually call gc.collect() every time a user disconnects

Question 12

A company is developing a scientific simulation framework where many different solvers must be interchangeable. The framework should enforce that each solver implements methods 'initialize' and 'step'. Developers want to use abstract base classes. Which approach should the team take to ensure that any subclass of 'Solver' cannot be instantiated unless it defines both methods?

Accepted Answer

Inherit from ABC and decorate both methods with @abstractmethod. Inheriting from `ABC` (from the `abc` module) and decorating both `initialize` and `step` with `@abstractmethod` enforces that any concrete subclass must override these methods. Attempting to instantiate a subclass that does not implement all abstract methods raises a `TypeError`, ensuring compile-time-like safety at runtime.

Answer

Define an interface in a separate module and check using isinstance

Answer

Use @abstractmethod without inheriting from ABC

Answer

Define Solver with methods that raise NotImplementedError

Question 13

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

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

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 Python exposes the computed MRO as a tuple through the __mro__ attribute on every class (and also via ClassName.mro()), so it can be inspected directly. Option B is correct because since Python 2.3 the MRO is computed using the C3 linearization algorithm, which guarantees a consistent, monotonic ordering that respects local precedence and the order of base classes. Option D is correct because in a diamond hierarchy C3 linearization places the most derived class first and the common topmost base class (e.g., object) last, after all intermediate classes. Option C is not correct because the MRO governs attribute lookup in general, including non-method attributes such as data descriptors and class variables, not just methods. Option E is not correct because the MRO is computed once when the class is created and is stored in the class's __mro__; altering the class hierarchy at runtime does not recompute or allow modification of an existing class's MRO.

Answer

The MRO is only used for methods, not attributes.

Answer

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