PCAP Object-Oriented Programming Practice Test 8 — 15 Questions

Question 1

Refer to the exhibit. What is printed?

Accepted Answer

3
3. The code defines a class `A` with a class attribute `x = 3`. Inside `__init__`, the first `print(self.x)` accesses the class attribute (since no instance attribute exists yet), printing `3`. The statement `self.x += 1` is equivalent to `self.x = self.x + 1`; it reads the class attribute for the right-hand side, evaluates to `4`, and then creates a new instance attribute `x` with value `4`, shadowing the class attribute. The second `print(A.x)` explicitly accesses the class attribute, which remains `3`. Hence the output is `3` and `3` on separate lines.

Answer

3
6

Answer

3
Error

Answer

Error
3

Question 2

A developer creates classes `A`, `B(A)`, `C(A)`, and `D(B, C)`. When calling a method from `D` that is defined in `A`, which class's version is used according to Python's MRO?

Accepted Answer

The method from A, found through B then C.. Python's Method Resolution Order (MRO) for class `D(B, C)` follows the C3 linearization algorithm, which ensures a depth-first left-to-right search while preserving monotonicity. For `D(B, C)`, the MRO is `D -> B -> C -> A`, so a method defined in `A` that is not overridden in `B` or `C` will be found via `B` first, then `C`, and finally `A`. Option D correctly states that the method from `A` is used, found through `B` then `C`, which matches the actual resolution path.

Answer

The method from B, because it is the first parent.

Answer

The method from C, because it appears after B.

Answer

The method from A, but only if B and C do not override it.

Question 3

A class has both `@classmethod` and `@staticmethod` decorators. What is a key difference between them?

Accepted Answer

A classmethod receives the class as first argument.. The key difference is that a `@classmethod` receives the class itself as the first implicit argument (conventionally named `cls`), allowing it to access or modify class-level state, while a `@staticmethod` receives no implicit first argument and behaves like a plain function, unable to access the class or instance. This makes option B correct because it accurately describes the distinguishing feature of a classmethod.

Answer

A classmethod cannot be called on an instance.

Answer

A staticmethod must be called from the class only.

Answer

A classmethod cannot access class variables.

Question 4

Refer to the exhibit. What is the output? (Note: actual MRO may vary; choose the one that matches Python 3 C3 linearization.)

Accepted Answer

(, , , , ). Python 3 uses C3 linearization to compute the Method Resolution Order (MRO). For class D inheriting from B and C, which both inherit from A, the MRO is D, B, C, A, object. This satisfies the monotonicity and local precedence order: B comes before C (as per D's bases), and A is last among the user-defined classes, with object always appended.

Answer

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>)

Answer

(<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Answer

(<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>)

Question 5

A programmer writes a class with a method that should be called on the class itself, not on instances. Which decorator is appropriate?

Accepted Answer

@classmethod. The @classmethod decorator transforms a method so that it receives the class itself as the first implicit argument (cls), rather than an instance (self). This allows the method to be called on the class directly, e.g., MyClass.my_method(), and is the correct choice when a method should operate on the class level, not on instances.

Answer

@property

Answer

@abstractmethod

Answer

@staticmethod

Question 6

A class inherits from two parent classes that both have a method with the same name. When calling the method on the child, only one parent's version is executed. What Python mechanism determines which one?

Accepted Answer

Method Resolution Order (MRO).. Python uses the C3 linearization algorithm to compute the Method Resolution Order (MRO) for a class. When a method is called on an instance, Python searches the MRO from left to right and executes the first implementation it finds. This ensures a consistent and predictable order of inheritance, even in diamond or multiple-inheritance scenarios.

Answer

Method overloading by signature.

Answer

Explicit super() call in the child class.

Answer

Inheritance depth (closest parent wins).

Question 7

You are designing a class that should behave like a sequence and support slicing. Which special methods must be implemented?

Accepted Answer

__getitem__ and __len__. For a class to support slicing in Python, it must implement both `__getitem__` (to handle indexing and slice objects) and `__len__` (to define the sequence length, which is required for proper slice boundary handling). Together, these satisfy the sequence protocol, enabling Python's slicing syntax like `obj[start:stop:step]`.

Answer

__len__ and __contains__

Answer

__iter__ and __next__

Answer

__getitem__ alone

Answer

__getitem__ and __setitem__

Question 8

A programmer wants to create a class that cannot be instantiated directly, only through a factory method. Which approach should be used?

Accepted Answer

Override __new__ to raise an exception unless called from a classmethod factory.. Overriding `__new__` allows the programmer to control instance creation at the lowest level. By checking the call stack or a flag set by a classmethod factory, `__new__` can raise an exception when instantiation is attempted directly, while still allowing the factory method to create instances. This ensures the class cannot be instantiated directly, only through the designated factory.

Answer

Raise an exception in __init__ if called directly.

Answer

Define the class as abstract using ABC and @abstractmethod.

Answer

Use a metaclass to prevent instantiation.

Question 9

A class defines an __init__ method that takes optional arguments. What is the correct way to provide default values?

Accepted Answer

Use default parameter values in the __init__ signature.. Python's `__init__` method, like any other function, supports default parameter values in its signature. This is the idiomatic and simplest way to provide default values for instance attributes, as the defaults are evaluated at function definition time and assigned to the parameter when no argument is provided.

Answer

Use class variables to store defaults.

Answer

Override __new__ to set default values.

Answer

Use a separate setter method called after instantiation.

Question 10

A company needs to model different types of employees. They have a base class `Employee` with a method `calculate_pay()`. For hourly employees, pay = hours * rate; for salaried employees, pay = salary. Which design approach is most appropriate?

Accepted Answer

Create subclasses `HourlyEmployee` and `SalariedEmployee` that override `calculate_pay()`.. It applies polymorphism through method overriding: each subclass (`HourlyEmployee`, `SalariedEmployee`) provides its own implementation of `calculate_pay()`, allowing the calling code to treat all employees uniformly via the base class interface. This adheres to the Open/Closed Principle and keeps the design extensible without modifying existing code when new employee types are added.

Answer

Use a `@staticmethod` inside `Employee` to compute pay based on a type parameter.

Answer

Define a module-level function that takes an employee object and computes pay.

Answer

Use a single `Employee` class with conditional statements to differentiate pay types.

Question 11

A team is implementing a shape hierarchy with a base class `Shape` that should have an `area()` method. They want to ensure that every subclass must provide its own implementation of `area()`. Which approach should they use?

Accepted Answer

Use `@abstractmethod` from the `abc` module to declare `area()` as abstract.. The `abc` module provides the `ABCMeta` metaclass and the `@abstractmethod` decorator, which together enforce that any concrete subclass must override the abstract method. If a subclass fails to implement `area()`, Python raises a `TypeError` at instantiation time, ensuring the design contract is upheld. This is the standard Pythonic way to define abstract base classes and enforce method implementation in subclasses.

Answer

Define `area()` in `Shape` and have it raise `NotImplementedError`.

Answer

Use a class method that must be overridden.

Answer

Define `area()` as a property that raises an error.

Question 12

A class `ServerConfig` has a class attribute `port = 8080`. After deployment, a developer runs `ServerConfig.port = 9090` in one module, and unexpectedly all existing instances now use port 9090. What concept explains this behavior?

Accepted Answer

Class attributes are shared among all instances of a class.. Class attributes in Python are shared across all instances of a class. When you modify `ServerConfig.port` on the class itself, every instance that accesses `port` via the class (or via an instance that hasn't overridden it) sees the new value. This is fundamental to Python's attribute lookup mechanism: instance attributes shadow class attributes, but if no instance attribute exists, the class attribute is used.

Answer

Instance attributes always override class attributes.

Answer

The attribute is immutable.

Answer

Python uses copy-on-write for attribute access.

Question 13

A developer wants to create a class that logs every attribute access on an instance. Which special method should they override?

Accepted Answer

`__getattribute__`. `__getattribute__` is the special method that is called unconditionally for every attribute access on an instance, making it the appropriate choice for logging all attribute accesses. Overriding this method allows the developer to intercept and log each access before the attribute is retrieved, whereas `__getattr__` is only invoked when the attribute is not found via normal lookup.

Answer

`__getattr__`

Answer

`__setattr__`

Answer

`__delattr__`

Question 14

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?

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 15

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)`