PCAP Object-Oriented Programming Practice Test 7 — 15 Questions

Question 1

Refer to the exhibit. What is the output?

Accepted Answer

DBCA. The MRO for class D using C3 linearization is D -> B -> C -> A. Therefore, D calls super() to B, B calls super() to C, C calls super() to A. Output: D B C A (as a concatenated string).

Answer

DBACA

Answer

DCBA

Answer

DBAC

Answer

Error

Question 2

A developer defines a class with an __init__ method that sets instance attributes. Which of the following is the correct way to call the parent class's __init__ from a child class?

Accepted Answer

super().__init__(arg1, arg2). In Python, to call the parent class's __init__ method, you should use super().__init__() with the appropriate arguments. This ensures proper initialization in inheritance hierarchies.

Answer

super(self, Child).__init__(arg1, arg2)

Answer

Parent.__init__(self, arg1, arg2)

Answer

Child.__init__(self, arg1, arg2)

Question 3

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

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 is used in abstract base classes to declare methods that must be implemented by concrete subclasses. It cannot be instantiated directly if any abstract methods are present.

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.

Question 5

A programmer wants to ensure that a class attribute is the same for all instances and can be accessed via the class name. Which type of variable should be defined?

Accepted Answer

Class variable. Option D is correct because a class variable in Python is defined directly within the class body (outside any method) and is shared across all instances. It can be accessed via the class name (e.g., `ClassName.var`) or through any instance, ensuring the same value for all objects.

Answer

Global variable

Answer

Instance variable

Answer

Local variable inside a method

Question 6

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

Which of the following is a correct use of the @property decorator to create a getter and setter for an attribute named 'score' that ensures score stays between 0 and 100?

Accepted Answer

@property
def score(self): return self._score
@score.setter
def score(self, value): if 0 <= value <= 100: self._score = value. The @property decorator creates a getter method. The @score.setter decorator creates a setter that validates the value. Inside the setter, you should assign to a private attribute like _score to avoid recursion.

Answer

@property
def _score(self): return self.score
@_score.setter
def _score(self, value): self.score = value

Answer

@property
def score(self): return self.score
@score.setter
def score(self, value): self.score = value

Answer

def get_score(self): return self._score
def set_score(self, value): self._score = value
score = property(get_score, set_score)

Question 8

A class has a method that does not access any instance or class data. What decorator should be used to define it as a utility method that can be called on the class itself without requiring an instance?

Accepted Answer

@staticmethod. The @staticmethod decorator is used for methods that do not depend on the class or instance state. They can be called on both instances and the class.

Answer

@property

Answer

@abstractmethod

Answer

@classmethod

Question 9

Given the following code: class Parent: def show(self): print('Parent') class Child(Parent): def show(self): print('Child') c = Child(); c.show(); super(Child, c).show(). What is the output?

Accepted Answer

Child Parent. Option B is correct because the code first calls `c.show()`, which invokes the overridden `show()` method in the `Child` class, printing 'Child'. Then `super(Child, c).show()` calls the `show()` method of the `Parent` class (the superclass of `Child`) on the same instance `c`, printing 'Parent'. Thus the output is 'Child Parent'.

Answer

Parent Child

Answer

Child Child

Answer

Parent Parent

Question 10

Which of the following is true regarding Python's method resolution order (MRO) in multiple inheritance?

Accepted Answer

The MRO is computed using the C3 linearization algorithm, ensuring that each class appears before its parents and that monotonicity is preserved.. Option A is correct because Python's method resolution order (MRO) is computed using the C3 linearization algorithm. This algorithm ensures that each class appears before its parents and that monotonicity is preserved, meaning the order of class precedence does not change when new subclasses are introduced. This is essential for resolving method calls in multiple inheritance scenarios, particularly with diamond inheritance.

Answer

The MRO is always the same as the order of base classes specified in the class statement.

Answer

The MRO can be changed at runtime by modifying the __bases__ attribute of a class.

Answer

The MRO is determined by the order of base classes in the class definition, using a depth-first, left-to-right search without consideration of diamond inheritance.

Question 11

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

Accepted Answer

A subclass can override a parent class method.. Option B is correct because Python allows a subclass to define a method with the same name as a method in its parent class, which overrides the parent's implementation. When the method is called on an instance of the subclass, Python's method resolution order (MRO) will find the subclass's version first, effectively hiding the parent's method.

Answer

If a subclass does not define __init__, it automatically inherits the parent's __init__.

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 12

Which TWO of the following are valid ways to define a class method in Python? (Select exactly two.)

Accepted Answer

def my_method(cls): pass
my_method = classmethod(my_method). Option A is correct because it manually applies the `classmethod()` built-in function to a regular function, converting it into a class method. This is a valid, though less common, way to define a class method, as the `classmethod` descriptor wraps the function so that the first argument passed is the class (`cls`), not an instance.

Answer

class MyClass:
    def my_method(cls): pass

Answer

def my_method(self): pass

Answer

@staticmethod
def my_method(cls): pass

Question 13

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

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

Accepted Answer

AttributeError. Option A is correct because the code attempts to access the attribute `balance` on an instance of the `BankAccount` class, but the class defines only `__init__` and `deposit` methods, and no `balance` attribute is ever set. In Python, accessing a non-existent attribute raises an `AttributeError`, not returning a default value or silently failing.

Answer

0

Answer

None

Answer

100

Question 15

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

Accepted Answer

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

PCAP Object-Oriented Programming Practice Test 7 — 15 Questions

Exhibit

PCAP Object-Oriented Programming Practice Test 7 — 15 Questions

Exhibit