PCAP Object-Oriented Programming Practice Test 4 — 15 Questions

Question 1

A team is using inheritance but wants to prevent a method from being overridden in subclasses. What Python feature can enforce this?

Accepted Answer

Use a @final decorator.. The `@final` decorator, introduced in Python 3.8 via the `typing` module, is specifically intended to mark a method as final, signaling that it should not be overridden in subclasses. While Python does not enforce this at runtime, type checkers (e.g., mypy) can flag violations, making it the correct feature for preventing overriding in a design intent context. Option A, the double underscore prefix, only triggers name mangling (`_ClassName__method`), which is meant to avoid accidental collisions but does not prevent a subclass from defining a method with the mangled name directly, thus it does not enforce non-overridability.

Answer

Use a private method with double underscore prefix (__method).

Answer

Use @staticmethod.

Answer

Use @abstractmethod.

Question 2

A class has an attribute that should be computed on access and cached for subsequent accesses. Which pattern is most appropriate?

Accepted Answer

Use a custom descriptor that caches the value in the instance's __dict__.. A custom descriptor with a __get__ method can compute the attribute value on first access and store it in the instance's __dict__ for subsequent accesses. This pattern, often called a cached property, ensures the computation happens only once per instance, which is exactly what the question requires.

Answer

Use __slots__ to define the attribute.

Answer

Use a @classmethod to compute the value.

Answer

Use a @staticmethod to compute the value.

Question 3

When a class defines both __getattr__ and __getattribute__, which one is called when accessing an attribute that exists in the instance?

Accepted Answer

__getattribute__ is called, and __getattr__ is not called.. In Python, when both __getattr__ and __getattribute__ are defined in a class, __getattribute__ is always called first for every attribute access. If the attribute exists in the instance (e.g., in the instance dictionary or via a descriptor), __getattribute__ returns it directly, and __getattr__ is never invoked. __getattr__ is only called as a fallback when __getattribute__ raises an AttributeError. Therefore, for an existing attribute, only __getattribute__ runs, making option D correct.

Answer

__getattr__ always overrides __getattribute__.

Answer

Both __getattr__ and __getattribute__ are called, in that order.

Answer

Only __getattr__ is called.

Question 4

Which TWO of the following are valid ways to define a class attribute that is shared among all instances?

Accepted Answer

Assign the attribute inside a classmethod using cls.. A classmethod receives the class (cls) as its first argument, allowing you to assign or modify a class attribute via `cls.attribute = value`. This assignment affects the class itself, making the attribute shared among all instances, as the attribute is stored on the class object, not on instance dictionaries.

Answer

Assign the attribute inside a staticmethod.

Answer

Use the @property decorator.

Answer

Assign the attribute inside __init__ using self.

Question 5

Which TWO statements about inheritance in Python are true?

Accepted Answer

Abstract base classes can be instantiated if they have no abstract methods.. Abstract base classes can be instantiated if they have no abstract methods; Python does not prevent instantiation in that case. Option B is correct because Python's Method Resolution Order (MRO) is determined by the C3 linearization algorithm. Option D is correct: Python supports multiple inheritance. Option C is false: private attributes (with double underscore) are name-mangled to _Classname__attr, making them inaccessible directly in subclasses. Option E is false: super() returns a proxy object that follows the MRO, not a direct parent class instance.

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 6

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

Accepted Answer

__init__. To create an immutable object that supports iteration and membership testing, you need __init__ to set the initial data (assuming immutability is handled separately), and either __iter__ or __getitem__ to enable iteration. Membership testing falls back to iteration when __contains__ is not defined. __len__ and __contains__ are optional. Thus, a minimal set is __init__ plus one of __iter__/__getitem__.

Answer

__getitem__

Answer

__len__

Answer

__contains__

Question 7

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

Accepted Answer

2. The code defines a class `MyClass` with a class attribute `x = 1`. The `__init__` method sets an instance attribute `self.x = 2`. When `obj.x` is accessed, Python first looks for an instance attribute, finding `self.x = 2`, so it prints `2`. Option D is correct because instance attributes shadow class attributes.

Answer

AttributeError

Answer

None

Answer

1

Question 8

Refer to the exhibit. What is the root cause of the error?

Accepted Answer

The attribute 'age' is not defined in the class or instance.. The error 'AttributeError: 'ClassName' object has no attribute 'age'' occurs when code attempts to access an instance attribute that has never been defined. In Python, attributes must be assigned (e.g., in __init__ or directly on the instance) before they can be read; simply declaring a class-level variable named 'age' would not cause this error, but if no assignment exists, the attribute is missing.

Answer

The __init__ method was not called.

Answer

The attribute 'age' is private.

Answer

The attribute 'age' is a class attribute but not initialized.

Question 9

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 10

A class `Point` has an `__init__` that sets `self.x` and `self.y`. They want to compare points by equality (i.e., `p1 == p2` should work correctly). Which method should they implement?

Accepted Answer

`__eq__`. In Python, the `__eq__` method is the correct way to define equality comparison for objects. When you implement `__eq__(self, other)`, it is automatically called by the `==` operator, allowing `p1 == p2` to return a Boolean based on custom logic (e.g., comparing `self.x` and `self.y`). This is the standard Python protocol for equality testing.

Answer

`__same__`

Answer

`__compare__`

Answer

`__cmp__`

Question 11

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 12

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 13

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 14

A class named Counter has a class variable count and an instance method increment. The method is defined as def increment(self): Counter.count += 1. What will be the output after executing the following code? c1 = Counter(); c2 = Counter(); c1.increment(); c2.increment(); print(Counter.count, c1.count, c2.count)

Accepted Answer

2 2 2. The class variable `count` is shared across all instances of the `Counter` class. The `increment` method modifies `Counter.count` directly, so after two calls, `Counter.count` becomes 2. Since `c1.count` and `c2.count` refer to the same class variable (they do not have instance attributes shadowing it), both instances reflect the same value of 2.

Answer

2 1 1

Answer

1 1 1

Answer

0 0 0

Question 15

Which of the following best describes the use of the @abstractmethod decorator in Python?

Accepted Answer

It indicates that a method must be overridden in any non-abstract subclass.. The @abstractmethod decorator, when used in conjunction with a metaclass like ABC (Abstract Base Class) or by inheriting from ABC, declares a method as abstract. This forces any concrete (non-abstract) subclass to provide an override of that method; otherwise, Python raises a TypeError at instantiation time. Option B correctly captures this mandatory override requirement.

Answer

It automatically provides a default implementation for a method.

Answer

It creates a method that can be called without an instance.

Answer

It raises AttributeError if the method is called.