PCAP Object-Oriented Programming Practice Test 8 — 15 Questions

Question 1

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 2

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. C is correct because the C3 linearization algorithm merges the linearizations of parent classes while preserving local precedence order and monotonicity. For class D(B, C), the linearization is D + merge(L(B), L(C), [B, C]). L(B) = B, A, object; L(C) = C, A, object. Merging yields D, B, C, A, object (object is often omitted in option lists). This respects that B precedes C in D's bases and that A appears after both B and C.

Answer

D -> B -> A -> object

Answer

D -> B -> C -> A -> object

Answer

D -> B -> A -> C

Question 3

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. Option C is correct because 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 4

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

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. Option C is correct because 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 6

A developer defines a subclass 'Dog' that overrides the '__init__' method of the parent class 'Animal'. The parent class __init__ sets a 'species' attribute. Which code ensures the parent __init__ is called correctly in Python 3?

Accepted Answer

class Dog(Animal): def __init__(self, name): super().__init__(); self.name = name. Option A is correct because it uses `super().__init__()` without arguments, which calls the parent `Animal.__init__` method as per Python 3's cooperative multiple inheritance model. Since the parent `__init__` sets `species` without requiring any parameters, this ensures the `species` attribute is initialized before `self.name` is set in the subclass.

Answer

class Dog(Animal): def __init__(self, name): self.name = name

Answer

class Dog(Animal): def __init__(self, name): super().__init__(name); self.name = name

Answer

class Dog(Animal): def __init__(self, name): Animal.__init__(self); self.name = name

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). Option B is correct because `__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 defines a class 'MathUtils' with a method that performs a calculation either on the class or on instances. Which method type should be used for a method that does not depend on instance state but can be called on the class?

Accepted Answer

@classmethod
def add(cls, a, b): return a + b. Option B correctly uses @classmethod, which receives the class as first argument and can be called on the class or instance. Option A uses @staticmethod, which does not receive cls. Option C is a regular instance method requiring self. Option D uses @property, which is for attribute-like access.

Answer

def add(self, a, b): return a + b

Answer

@property
def add(self): return lambda a,b: a+b

Answer

@staticmethod
def add(a, b): return a + b

Question 9

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 10

A developer wants to create a custom descriptor that validates attribute values upon assignment. Which code snippet correctly implements a descriptor that ensures the assigned value is an integer?

Accepted Answer

class Integer: def __set_name__(self, owner, name): self.name = name; def __set__(self, obj, val): if not isinstance(val, int): raise TypeError; obj.__dict__[self.name]=val. Option B correctly implements a descriptor by defining both __set_name__ and __set__ methods. __set_name__ stores the attribute name, and __set__ validates that the assigned value is an integer before storing it in the instance's __dict__, which is the standard pattern for descriptors in Python.

Answer

class Integer: @property
def value(self): return self._value; @value.setter
def value(self, val): if not isinstance(val, int): raise TypeError; self._value = val

Answer

class Integer: def __get__(self, obj, objtype): return obj.__dict__[self.name]

Answer

class Integer: def __set__(self, obj, val): if not isinstance(val, int): raise TypeError; obj.__dict__[self.name]=val

Question 11

Which TWO statements about the use of __slots__ in a class are correct?

Accepted Answer

It restricts instance attributes to only those named in __slots__. Option C is correct because when you define `__slots__` in a class, Python creates a descriptor for each slot name and restricts the instance to only those attributes. Any attempt to set an attribute not listed in `__slots__` raises an `AttributeError`. This is a core feature of `__slots__` to enforce a fixed set of instance attributes.

Answer

It prevents the class from being instantiated

Answer

It is inherited by subclasses automatically

Answer

It improves method lookup speed

Question 12

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

Accepted Answer

Python supports multiple inheritance. Option B is correct because 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 13

Which TWO statements about method overriding in Python are correct?

Accepted Answer

The overriding method can call the parent method using super(). Option A is correct because 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 14

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

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

PCAP Object-Oriented Programming Practice Test 8 — 15 Questions

Exhibit

PCAP Object-Oriented Programming Practice Test 8 — 15 Questions

Exhibit