PCAP Object-Oriented Programming Practice Test 8 — 15 Questions

Question 1

A programmer uses a class method to create an alternative constructor for a `Point` class. The method should parse a string like "10,20" and return a `Point` instance with x=10, y=20. Which code snippet correctly implements this?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

`@classmethod
def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`. It uses the `@classmethod` decorator, which automatically passes the class (`cls`) as the first argument. This allows the method to create an instance of the class using `cls(...)`, making it a proper alternative constructor that works correctly even if the class is subclassed. The method parses the string "10,20" by splitting on the comma and converting the parts to integers.

Answer

`def from_string(self, s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`@staticmethod
def from_string(s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`

Question 2

Consider a class `D` that inherits from multiple base classes `B` and `C`. The developer wants to call a method from a specific parent class while ensuring correct method resolution order (MRO). Which is the safest way?

Accepted Answer

`super().method()`. In Python, `super().method()` is the safest way to call a method from a parent class in a multiple inheritance scenario because it respects the Method Resolution Order (MRO) defined by the C3 linearization algorithm. This ensures that the method is resolved from the next class in the MRO, avoiding hard-coded references that could break if the inheritance hierarchy changes. It also correctly handles cooperative multiple inheritance, where each class in the MRO can collaborate via `super()` calls.

Answer

`self.method()`

Answer

`ParentClass.method(self)`

Answer

`BaseClass.method(self)`

Question 3

A class has a class attribute that is a list. A developer modifies this list via one instance, and the change is reflected in all other instances. What is the best practice to avoid this unintended sharing?

Accepted Answer

Initialize the list in `__init__` rather than as a class attribute.. Class attributes are shared across all instances. By initializing the list inside `__init__`, each instance gets its own independent list object, preventing unintended mutation from affecting other instances. This is the standard Python pattern for instance-specific mutable data.

Answer

Use a tuple instead of a list.

Answer

Use a class method to modify the list.

Answer

Use `deepcopy` when accessing the list.

Question 4

Which of the following correctly uses `__slots__` to restrict attribute creation to only `x` and `y`?

Accepted Answer

`class Foo: __slots__ = ['x', 'y']`. Options C and D are both correct because `__slots__` must be assigned an iterable of strings. A list `['x', 'y']` and a tuple `('x', 'y')` are both valid iterables that restrict attribute creation to exactly `x` and `y`. Option A uses a single string, which would restrict to individual characters `'x'`; Option B uses a string in parentheses without a trailing comma, which is also just a string. Both A and B would produce unexpected behavior.

Answer

`class Foo: __slots__ = 'x'`

Answer

`class Foo: __slots__ = ('x')`

Question 5

Which TWO of the following are special methods in Python?

Accepted Answer

`__init__`. In Python, special methods (also called dunder or magic methods) are predefined methods with names of the form __name__ that the interpreter invokes implicitly to implement language features. Option C, `__init__`, is the initializer special method that Python calls automatically when an instance is created, e.g., `obj = MyClass()`, to set up the object's initial state. Option D, `__str__`, is the special method that Python calls by default by `str(obj)` and `print(obj)` to produce a human-readable string representation of the object. By contrast, options A (`__bar__`) and E (`__foo__`) merely follow the double-underscore naming pattern but are not defined by the Python data model as special methods, so they are ordinary attributes. Option B, `__main__`, is not a method at all; it is the name of the top-level execution scope (the value of `__name__` for the main script) and the conventional module name checked with `if __name__ == "__main__":`.

Answer

`__bar__`

Answer

`__main__`

Answer

`__foo__`

Question 6

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

Accepted Answer

It can be called manually.. The __init__ method is a special method in Python classes used for initializing newly created objects. It can be called manually (e.g., obj.__init__()), it accepts arguments that are passed during instance creation, and it is automatically invoked when an instance is created via the class constructor. It does not require a return value (it returns None), and it is inherited by subclasses unless explicitly overridden.

Answer

It must return a value.

Answer

It is not inherited.

Question 7

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). `super().__init__(arg1, arg2)` is the modern, recommended way to call the parent class's `__init__` method in Python. It uses the `super()` function without arguments to automatically resolve the parent class based on the method resolution order (MRO), ensuring proper cooperative multiple inheritance and avoiding hardcoding the parent class name.

Answer

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

Answer

Parent.__init__(self, arg1, arg2)

Answer

Child.__init__(self, arg1, arg2)

Question 8

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 9

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.

Question 10

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 11

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. It uses the @property decorator to define a getter method that returns the private attribute `self._score`, and a setter method that validates the new value is between 0 and 100 before assigning it to `self._score`. This ensures encapsulation and data validation, which is the intended use of properties in Python.

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 12

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. A @staticmethod decorator defines a method that does not receive an implicit first argument (self or cls). It can be called on the class itself without creating an instance, making it suitable for utility functions that do not access instance or class data. This matches the requirement.

Answer

@property

Answer

@abstractmethod

Answer

@classmethod

Question 13

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 14

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 15

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