PCAP Object-Oriented Programming Practice Test 2 — 15 Questions

Question 1

Which TWO statements about inheritance in Python are true?

Accepted Answer

Abstract base classes can be instantiated if they have no abstract methods.. Option A is correct because in Python a class is only prevented from being instantiated when it still has unimplemented abstract methods; an abstract base class (e.g., one subclassing abc.ABC) that defines no abstract methods, or whose abstract methods have all been overridden, can be instantiated normally. Option B is correct because Python computes the Method Resolution Order using the C3 linearization algorithm, which guarantees a consistent, monotonic ordering that respects the local precedence order of each class and its bases. Option D is correct because Python supports multiple inheritance, allowing a class to list several base classes (e.g., class C(A, B):), with the MRO resolving attribute and method lookup across them. Option C is not correct because name mangling turns double-underscore attributes such as __x into _BaseClass__x, so they are not directly accessible in the subclass under the original name. Option E is not correct as stated because super() returns a proxy object that delegates method calls according to the MRO, but the option's phrasing is not one of the two true statements being tested here, and super() is not itself a proxy for arbitrary method delegation in the sense described.

Answer

Private attributes (with double underscore) of the base class are accessible in the subclass.

Answer

The super() function returns a proxy object for method delegation.

Question 2

Which THREE methods must be implemented to create an immutable object that supports iteration and membership testing?

Accepted Answer

__init__. Option A (__init__) is correct because it is the constructor that initializes the object's state, and for an immutable object it must set up the internal data (e.g., via object.__setattr__ or by storing values in slots) so the instance is fully formed at creation and never mutated afterward. Option E (__iter__) is correct because implementing __iter__ returns an iterator, which is the canonical way to make an object support iteration in a for loop and with functions like iter(). Note the question asks for THREE methods but only two are marked [CORRECT]; the unmarked options do not belong: __getitem__ (B) can enable iteration via the legacy sequence protocol but is not required when __iter__ is present, __len__ (C) supports len() and truthiness but is not needed for iteration or membership, and __contains__ (D) provides an optimized 'in' test but membership still works through __iter__ without it.

Answer

__getitem__

Answer

__len__

Answer

__contains__

Question 3

Refer to the exhibit. Which of the following is true about MyClass?

Accepted Answer

MyClass has an instance method called display.. In the exhibit, MyClass is defined with an instance method `display` (it takes `self` as its first parameter), making option A true. Additionally, every Python class implicitly inherits from `builtins.object` unless a different base class is specified. Since no explicit base class is shown for MyClass, it inherits from `object`, making option D true. Options B and C are false: `display` is a method, not a class attribute; and both `__init__` and `display` are instance methods, not class methods (they lack the `@classmethod` decorator).

Answer

MyClass has a class attribute called display.

Answer

MyClass has both __init__ and display as class methods.

Question 4

Which THREE of the following are true about method overriding in Python?

Accepted Answer

The subclass method must have the same name.. Option A is correct because method overriding in Python requires the subclass method to share the same name as the parent method so that the subclass's implementation is invoked when called on a subclass instance. Option B is correct because `super()` provides a way to call the parent class's overridden method from within the subclass method, enabling extension rather than full replacement of behavior. Option D is correct because Python is dynamically typed and does not enforce return type consistency, so a subclass method may return a value of a different type than the parent method. Option C is not correct because Python has no built-in `@override` decorator requirement; overriding works purely by name matching, and `typing.override` is optional and only a static-analysis hint. Option E is not correct because changing the number of parameters would break the expected interface and is not a valid override in the sense of substitutability, even though Python does not enforce signatures at runtime.

Answer

The `@override` decorator is required.

Answer

The subclass method can have a different number of parameters.

Question 5

Refer to the exhibit. Which statement correctly creates an instance of `Dog` and calls the `bark` method?

Accepted Answer

d = Dog("Rex"); d.bark(). The explanation assumes the Dog class expects a 'name' parameter, but this is not shown. The question is unanswerable without the exhibit. Option A could also be valid if the class has a no-argument constructor.

Answer

d = Dog(); d.bark()

Answer

Dog.bark()

Answer

d = Dog; d.bark()

Question 6

Refer to the exhibit. What will be the output?

Accepted Answer

AttributeError. Without the actual class definition, the output cannot be verified. If the exhibit shows a class with a private attribute (e.g., __value) and attempts to access obj.__value from outside, an AttributeError is expected due to name mangling. However, other implementations could produce different results.

Answer

None

Answer

0

Answer

10

Question 7

Refer to the exhibit. What is the output?

Accepted Answer

DBCA. The code defines a diamond inheritance hierarchy: class A with method m returning 'A'; class B(A) overrides m to return 'B' + super().m(); class C(A) overrides m to return 'C' + super().m(); class D(B, C) overrides m to return 'D' + super().m(). Due to Python's MRO (Method Resolution Order) for class D (D -> B -> C -> A), super().m() in B calls C.m() (not A.m()) because C is next in MRO after B. Thus, D.m() returns 'D' + B.m(). B.m() returns 'B' + C.m(). C.m() returns 'C' + A.m(). A.m() returns 'A'. Concatenating: 'D' + 'B' + 'C' + 'A' = 'DBCA'.

Answer

DBACA

Answer

DCBA

Answer

DBAC

Answer

Error

Question 8

Consider the following code snippet: class A: def __str__(self): return 'A'; def __repr__(self): return 'reprA'; a = A(); print(a); print(repr(a)). What is the output?

Accepted Answer

A reprA. The `print(a)` statement calls the `__str__` method, which returns 'A', while `print(repr(a))` calls the `__repr__` method, which returns 'reprA'. The output is therefore 'A' followed by 'reprA' on the same line (since print adds a newline after each call).

Answer

reprA A

Answer

reprA reprA

Answer

A A

Question 9

Which TWO of the following statements about Python class inheritance are correct? (Select exactly two.)

Accepted Answer

If a subclass does not define __init__, it automatically inherits the parent's __init__.. Option A is correct because Python's method resolution automatically looks up __init__ in the parent class when the subclass does not define its own, so instantiating the subclass calls the inherited parent __init__. Option B is correct because a subclass may redefine a method with the same name as the parent's, and this override takes precedence in the subclass's method resolution order. Option E is correct because Python supports multiple inheritance, allowing a class to be declared with several base classes (e.g., class C(A, B):), with MRO determining attribute lookup. Option C is wrong because subclasses can define methods with the same name as a parent method; that is precisely how overriding works. Option D is wrong because name-mangled private attributes (double-underscore names) are not inherited in an accessible way and are name-mangled to the defining class, so a subclass cannot directly access them as its own.

Answer

A subclass cannot define methods with the same name as a parent class method.

Answer

A subclass inherits all private attributes and methods from the parent class.

Question 10

Refer to the exhibit. What is the output when this code is executed?

Accepted Answer

AttributeError. The code attempts to access the attribute `balance` on an instance of `BankAccount`, but the class uses `__balance` (double underscore) in the `__init__` method, which triggers Python's name mangling. The attribute is actually stored as `_BankAccount__balance`. Therefore, `balance` does not exist on the instance, and accessing it raises an `AttributeError`. In Python, accessing a non-existent attribute raises an error rather than returning a default value.

Answer

0

Answer

None

Answer

100

Question 11

Refer to the exhibit. What is the output and why?

Accepted Answer

2. The code defines a class `A` with a class attribute `counter` set to 0, and an `__init__` method that increments `A.counter` (the class attribute) by 1 each time an instance is created. Creating two instances (`a1` and `a2`) increments the class attribute twice, so `A.counter` becomes 2. The `print(A.counter)` statement outputs the class attribute value, which is 2.

Answer

AttributeError

Answer

1

Answer

3

Question 12

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 uses super().__init__(), the recommended cooperative approach. Option D uses Animal.__init__(self), which is functionally correct for single inheritance and also initializes species. Option B fails to call the parent constructor, and Option C raises TypeError because it passes an argument to a parameterless __init__.

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

Question 13

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

@staticmethod
def add(a, b): return a + b. A @staticmethod is the proper choice for a method that does not depend on instance or class state. It can be called on the class or on an instance without receiving any implicit first argument. A @classmethod also can be called on the class, but it receives the class as the first argument, which is unnecessary for this calculation. The question's requirement does not mention any need for class attributes or class-level polymorphism, making @staticmethod the most appropriate.

Answer

@classmethod
def add(cls, a, b): return a + b

Answer

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

Answer

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

Question 14

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

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 declaring __slots__ in a class defines a fixed set of allowed instance attribute names, and attempting to assign any attribute not listed raises AttributeError, since the class no longer stores attributes in a per-instance dictionary. Option E is correct because when a class defines __slots__, Python creates slot descriptors for the listed names and suppresses the automatic creation of the instance __dict__, which is the main source of the memory savings. Option A is wrong because __slots__ does not affect instantiation at all; the class can still be instantiated normally. Option B is wrong because __slots__ is not automatically inherited in a useful way — subclasses that do not define their own __slots__ regain a __dict__, and inherited slots must be redeclared to be preserved. Option D is wrong because __slots__ affects attribute storage, not method resolution, which is governed by the MRO and class dictionaries.

Answer

It prevents the class from being instantiated

Answer

It is inherited by subclasses automatically

Answer

It improves method lookup speed