PCAP Object-Oriented Programming Practice Test 7 — 15 Questions

Question 1

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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