PCAP Object-Oriented Programming Practice Test 5 — 15 Questions

Question 1

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. 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 2

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 3

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 4

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. 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 5

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.. 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 6

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__.. When a subclass does not define its own __init__, it inherits the __init__ method from the parent class, making it available to instances of the subclass. Option B is correct: Python subclasses can override parent class methods by defining a method with the same name. Option E is correct: Python supports multiple inheritance, allowing a class to inherit from more than one base class. Option C is incorrect: subclasses can define methods with the same name as parent methods (overriding). Option D is incorrect: private attributes (name-mangled with double underscore) are not fully inherited; they are renamed and cannot be accessed directly by their original name from subclasses.

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 7

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). 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 8

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.. 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 9

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 10

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 -> object. B is correct because the C3 linearization algorithm always includes 'object' at the end of the MRO. For class D(B, C), L(D) = D + merge(L(B), L(C), [B, C]). L(B) = B, A, object; L(C) = C, A, object. Merge yields D, B, C, A, object. Options that omit 'object' (like C) are incomplete.

Answer

D -> B -> A -> object

Answer

D -> B -> C -> A

Answer

D -> B -> A -> C

Question 11

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. 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 12

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. 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 13

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 14

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 15

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__