PCAP Object-Oriented Programming Practice Test 3 — 15 Questions

Question 1

Match each list method to its effect.

Question 2

A developer is implementing a simple counter class. The class should start at 0 and increment by 1 each time the 'increment' method is called. Which implementation is correct?

Accepted Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1. Option B is correct because it properly initializes an instance variable `self.count` to 0 in the `__init__` method and then uses `self.count += 1` in the `increment` method to modify the instance variable in place. The `+=` operator is a shorthand for `self.count = self.count + 1`, which correctly updates the counter each time `increment` is called.

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        count = self.count + 1

Answer

class Counter:
    def __init__(self):
        count = 0
    def increment(self):
        count += 1

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment():
        self.count += 1

Question 3

Consider the following class hierarchy: class A: def method(self): return 'A'; class B(A): pass; class C(A): def method(self): return 'C'; class D(B, C): pass. What is the output of D().method() according to Python's MRO?

Accepted Answer

'C'. Python's MRO (Method Resolution Order) for class D(B, C) is computed using the C3 linearization algorithm, which respects the local precedence order and monotonicity. The MRO for D is D -> B -> C -> A, so D().method() resolves to C.method(), returning 'C'. Option D is correct because C is the first class in the MRO that defines method().

Answer

'B'

Answer

TypeError

Answer

'A'

Question 4

A developer wants to ensure that the 'radius' attribute of a Circle class is always non-negative. Which implementation using @property is correct?

Accepted Answer

class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError
        self._radius = value. Option C is correct because it uses the @property decorator to define a getter and @radius.setter to define a setter that validates the radius value before assignment. The __init__ method correctly assigns to self.radius, which triggers the setter, ensuring the initial value is also validated. This pattern enforces the invariant that radius is always non-negative.

Answer

class Circle:
    def __init__(self, radius):
        self._radius = radius
    def radius(self):
        return self._radius

Answer

class Circle:
    def __init__(self, radius):
        self._radius = radius
    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError
        self._radius = value

Answer

class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def radius(self):
        return self._radius
    def set_radius(self, value):
        self._radius = value

Question 5

A class MyClass defines __str__ and __repr__ methods. What is the purpose of __repr__?

Accepted Answer

To return an unambiguous representation of the object, ideally for debugging. The `__repr__` method is designed to return an unambiguous string representation of an object, ideally one that can be used to recreate the object or that clearly shows its internal state for debugging purposes. This is distinct from `__str__`, which targets end-user readability. The Python documentation explicitly states that `__repr__` should be unambiguous, while `__str__` should be readable.

Answer

To return a human-readable string for end users

Answer

To compare object equality

Answer

To return a hash value of the object

Question 6

Consider the following code: class A: x = 1; class B(A): pass; class C(A): x = 2; class D(B, C): pass. What is D.x?

Accepted Answer

2. Option C is correct because Python's method resolution order (MRO) for class D, which uses multiple inheritance, follows the C3 linearization algorithm. The MRO for D is D, B, C, A, and since C defines x = 2, that attribute overrides the x = 1 from A in the inheritance chain, so D.x resolves to 2.

Answer

AttributeError

Answer

1

Answer

(1, 2) tuple

Question 7

Which of the following correctly uses an abstract base class to enforce that all subclasses implement a 'make_sound' method? (Assume ABC imported)

Accepted Answer

from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass. Option A is correct because it imports both `ABC` and `abstractmethod` from the `abc` module, defines `Animal` as a subclass of `ABC`, and decorates `make_sound` with `@abstractmethod`. This combination prevents instantiation of `Animal` and forces any concrete subclass to override `make_sound`, or else a `TypeError` is raised at instantiation time.

Answer

from abc import abstractmethod
class Animal:
    @abstractmethod
    def make_sound(self):
        pass

Answer

class Animal:
    def make_sound(self):
        return None

Answer

class Animal:
    def make_sound(self):
        raise NotImplementedError

Question 8

A subclass overrides a method but wants to call the parent class's version. Which keyword should be used?

Accepted Answer

super(). In Python, the `super()` function is used to call a method from the parent class. When a subclass overrides a method, `super().method_name()` allows the subclass to invoke the parent class's implementation, enabling cooperative multiple inheritance and proper method resolution order (MRO). This is the correct keyword for accessing the parent class's version of an overridden method.

Answer

base

Answer

parent

Answer

self

Question 9

Given: class A: def method(self): print('A'); class B(A): def method(self): super().method(); print('B'); class C(A): def method(self): super().method(); print('C'); class D(B, C): pass. What is printed by D().method()?

Accepted Answer

A C B. Option B is correct because Python's MRO (Method Resolution Order) for class D, which inherits from B and C (both inheriting from A), follows the C3 linearization algorithm. The MRO for D is D -> B -> C -> A, so calling D().method() triggers B.method(), which calls super().method() (resolving to C.method()), which calls super().method() (resolving to A.method()), printing 'A', then back to C prints 'C', then back to B prints 'B', resulting in 'A C B'.

Answer

A B C

Answer

C A B

Answer

B A C

Question 10

Which of these is NOT a characteristic of Python's descriptor protocol?

Accepted Answer

Descriptors are only used for attributes that are read-only. Option B is correct because descriptors are not limited to read-only attributes; they can control get, set, and delete operations. A descriptor that only implements `__get__` is a non-data descriptor, which can be overridden by instance attributes, while a data descriptor implements both `__get__` and `__set__` (and optionally `__delete__`), allowing full read-write control. The statement that descriptors are only for read-only attributes is false, as they are commonly used for computed properties, validation, and lazy evaluation.

Answer

A descriptor can be used to create properties with custom behavior

Answer

Class variables assigned to a descriptor are automatically intercepted

Answer

A descriptor must implement __get__

Question 11

Which TWO statements about static methods (@staticmethod) are correct?

Accepted Answer

They do not receive an implicit first argument.. Option A is correct because static methods in Python do not receive an implicit first argument like `self` (for instance methods) or `cls` (for class methods). They behave like plain functions but belong to a class's namespace, and are called without any automatic parameter injection.

Answer

They can access instance attributes via self.

Answer

They can access class variables only via cls.

Answer

They can only be defined inside a metaclass.

Question 12

Which THREE statements about inheritance in Python are correct?

Accepted Answer

A child class inherits all attributes and methods from its parent class.. Option A is correct because in Python, a child class inherits all non-private attributes and methods from its parent class by default. This includes both data attributes and methods, allowing the child to reuse and extend the parent's behavior without redefinition. Private attributes (with double underscore prefix) are name-mangled to _Classname__attribute, but they are still inherited in the sense that they exist in the child's namespace under the mangled name, though direct access by the original name is restricted.

Answer

Private attributes (with __) are inherited unchanged.

Answer

Python supports method overloading based on parameters.

Question 13

Which TWO statements about Python's name mangling are correct?

Accepted Answer

The mangled name format is _ClassName__attribute.. Option B is correct because Python's name mangling transforms an attribute name like `__attribute` defined in a class `MyClass` into `_MyClass__attribute`. This mechanism is specifically designed to avoid name clashes in subclasses, not to enforce privacy. The transformation is done by the compiler at definition time, not at runtime.

Answer

Name mangling applies to all method names that start with a single underscore.

Answer

Name mangling prevents external code from accessing the attribute entirely.

Answer

Name mangling occurs at runtime.

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

10. Option A is correct because the code defines a `__str__` method in `MyClass` that returns the string representation of `self.value`. When `print(obj)` is called, Python automatically invokes `__str__`, which returns `'10'` (the integer `10` converted to a string). The output is therefore `10`.

Answer

Error: 'MyClass' object has no attribute 'value'

Answer

<__main__.MyClass object at 0x...>

Answer

None

Question 15

Refer to the exhibit. Which of the following correctly shows the MRO of class D?

Accepted Answer

[D, B, C, A, object]. Option A is correct because Python's Method Resolution Order (MRO) for class D, which inherits from B and C (where B inherits from A and C inherits from A), follows the C3 linearization algorithm. The MRO is computed as D -> B -> C -> A -> object, ensuring that each class appears before its parents and that the order respects the local precedence order of D's bases (B before C).

Answer

[D, A, B, C, object]

Answer

[D, B, A, C, object]

Answer

[D, C, B, A, object]