PCAP Object-Oriented Programming Practice Test 6 — 15 Questions

Question 1

A developer wants to create a custom descriptor that validates attribute values upon assignment. Which code snippet correctly implements a descriptor that ensures the assigned value is an integer?

Accepted Answer

class Integer: def __set_name__(self, owner, name): self.name = name; def __set__(self, obj, val): if not isinstance(val, int): raise TypeError; obj.__dict__[self.name]=val. Ly implements a descriptor by defining both __set_name__ and __set__ methods. __set_name__ stores the attribute name, and __set__ validates that the assigned value is an integer before storing it in the instance's __dict__, which is the standard pattern for descriptors in Python.

Answer

class Integer: @property
def value(self): return self._value; @value.setter
def value(self, val): if not isinstance(val, int): raise TypeError; self._value = val

Answer

class Integer: def __get__(self, obj, objtype): return obj.__dict__[self.name]

Answer

class Integer: def __set__(self, obj, val): if not isinstance(val, int): raise TypeError; obj.__dict__[self.name]=val

Question 2

Which TWO statements about the use of __slots__ in a class are correct?

Accepted Answer

It restricts instance attributes to only those named in __slots__. When you define `__slots__` in a class, Python creates a descriptor for each slot name and restricts the instance to only those attributes. Any attempt to set an attribute not listed in `__slots__` raises an `AttributeError`. This is a core feature of `__slots__` to enforce a fixed set of instance attributes.

Answer

It prevents the class from being instantiated

Answer

It is inherited by subclasses automatically

Answer

It improves method lookup speed

Question 3

Which THREE of the following are true about Python's object-oriented programming features?

Accepted Answer

Python supports multiple inheritance. Python's class hierarchy supports multiple inheritance, allowing a class to inherit from more than one parent class. This is a core feature of Python's object-oriented programming model, implemented via the C3 linearization algorithm (Method Resolution Order, or MRO) to resolve method and attribute lookups unambiguously.

Answer

Python supports method overloading based on argument types

Answer

Python enforces access modifiers like private and protected

Question 4

Which TWO statements about method overriding in Python are correct?

Accepted Answer

The overriding method can call the parent method using super(). The overriding method can call the parent class's version of the method using the built-in `super()` function, which returns a proxy object that delegates method calls to the parent class. This is a fundamental feature of Python's inheritance mechanism, allowing the child method to extend or modify the parent's behavior while still invoking it.

Answer

The overriding method requires explicit use of the @override decorator

Answer

The overriding method must have the exact same parameter list

Answer

Overriding is resolved at compile time

Question 5

A company is developing a scientific simulation framework where many different solvers must be interchangeable. The framework should enforce that each solver implements methods 'initialize' and 'step'. Developers want to use abstract base classes. Which approach should the team take to ensure that any subclass of 'Solver' cannot be instantiated unless it defines both methods?

Accepted Answer

Inherit from ABC and decorate both methods with @abstractmethod. Inheriting from `ABC` (from the `abc` module) and decorating both `initialize` and `step` with `@abstractmethod` enforces that any concrete subclass must override these methods. Attempting to instantiate a subclass that does not implement all abstract methods raises a `TypeError`, ensuring compile-time-like safety at runtime.

Answer

Define an interface in a separate module and check using isinstance

Answer

Use @abstractmethod without inheriting from ABC

Answer

Define Solver with methods that raise NotImplementedError

Question 6

Which of the following statements about class inheritance in Python are true? (Choose two.)

Accepted Answer

Abstract base classes can be defined using the ABC module.. Python's `abc` module (Abstract Base Classes) allows you to define abstract base classes by inheriting from `ABC` and using the `@abstractmethod` decorator. This enforces that subclasses must implement the abstract methods, providing a formal interface contract.

Answer

A class can inherit from only one base class.

Answer

A child class can override any method from its parent class, but only if the method is declared as virtual.

Answer

The super() function is used to call a method from a sibling class.

Question 7

A developer is building a simulation of different types of vehicles. They have a base class Vehicle with an attribute speed initialized in __init__. They also have a subclass Car that inherits from Vehicle and adds an attribute fuel_type. The developer wants to ensure that every time a Car object is created, it also initializes the speed attribute from the Vehicle class. Which approach should the developer use?

Accepted Answer

In Car.__init__, call Vehicle.__init__(self) manually.. In Python, when a subclass overrides __init__, the parent class's __init__ is not automatically called. To ensure the speed attribute from Vehicle is initialized, the developer must explicitly call Vehicle.__init__(self) inside Car.__init__. This is a fundamental requirement of Python's inheritance mechanism for proper initialization of inherited attributes.

Answer

Override the __new__ method of Vehicle.

Answer

Use the @staticmethod decorator for initialization.

Answer

In Car.__init__, define speed directly without calling parent's __init__.

Question 8

A developer is implementing a caching system where object instances should be reused if they have the same set of initialization parameters. They want to control object creation so that calling MyClass(param1, param2) returns the same instance if it has been created before, otherwise creates a new one. They are considering overriding __new__ to implement this caching. However, they also need to ensure that __init__ is not called again for cached instances. What is the correct way to achieve this?

Accepted Answer

Override __call__ on the class metaclass.. To make MyClass(param1, param2) itself return cached instances without invoking __init__ on cache hits, override __call__ on the class's metaclass. The metaclass __call__ controls the class call syntax and can check a cache before creating a new instance. For new instances, it delegates to super().__call__() which runs __new__ and __init__. For cached instances, it returns the cached object directly, so __init__ is not called. Using a class method is a valid pattern but requires a different API (e.g., MyClass.get(...)), which contradicts the explicit 'calling MyClass(param1, param2)' requirement.

Answer

Override __new__ to return a cached instance, and override __init__ to do nothing if already initialized.

Answer

Use a class method as an alternative constructor and store instances in a class-level dictionary.

Answer

Override __new__ to return a cached instance if exists, and skip __init__ by checking if the instance is from cache.

Question 9

A team is developing a banking system in Python. They have a base class Account with attributes account_number and balance, and a method __init__(self, account_number, balance) that initializes these attributes. They then create a subclass SavingsAccount that adds an attribute interest_rate. In SavingsAccount's __init__, they assign self.interest_rate = rate but do not call super().__init__. When they instantiate SavingsAccount('12345', 1000, 0.02) and attempt to print(balance), an AttributeError occurs: 'SavingsAccount' object has no attribute 'balance'. What is the most appropriate fix to ensure that the SavingsAccount includes balance and account_number without code duplication?

Accepted Answer

Call super().__init__(account_number, balance) as the first line in SavingsAccount.__init__, then assign self.interest_rate = rate.. The correct fix is to call super().__init__(account_number, balance) in SavingsAccount.__init__ to reuse the base class initialization, then assign self.interest_rate = rate. This avoids code duplication and ensures balance and account_number are properly initialized. Option A would lose the interest_rate attribute. Option B duplicates code by manually assigning the base attributes. Option D breaks the initialization by making balance a class attribute, which is not appropriate for per-instance data.

Answer

Remove the __init__ method from SavingsAccount entirely and rely on the default __init__ from Account.

Answer

Manually assign self.account_number and self.balance in SavingsAccount.__init__ before assigning interest_rate.

Answer

Define balance as a class attribute in Account with a default value and remove it from __init__.

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

4. The explanation claims a method call increments the instance attribute, but the expression shown (A().a + A.a) contains no method call. Based on the described class (class attribute a=1, instance a=2), the result would be 3, not 4. The missing exhibit is critical, and the explanation is internally inconsistent.

Answer

3

Answer

Error

Answer

A object

Question 11

Refer to the exhibit. What is the output?

Accepted Answer

10. Base.method returns 3*2=6, Derived.method adds 4, so 10.

Answer

7

Answer

Error

Answer

14

Question 12

Refer to the exhibit. What is the output?

Accepted Answer

AttributeError. The code attempts to access an attribute that does not exist on the object. In Python, when you try to access an attribute that is not defined in the class or instance, the interpreter raises an AttributeError. Since the class does not have a method or property named 'x', calling obj.x triggers this exception.

Answer

0

Answer

None

Answer

10

Question 13

Refer to the exhibit. What is the output?

Accepted Answer

0 12.56. The Circle class has a class attribute pi=3.14 and an area method that returns pi * radius * radius. Two instances are created: c1 with radius=2 and c2 with radius=0. The code prints c2.area() followed by c1.area(), so the output is '0 12.56'. Therefore, option D is correct.

Answer

12.56 0

Answer

Error

Answer

0 0

Question 14

Refer to the exhibit. What is the output of the last line?

Accepted Answer

{'name': 'John', '_Employee__salary': 50000}. Python uses name mangling for attributes starting with double underscores (like `__salary`). When accessed via `vars()`, the mangled name `_Employee__salary` is shown, not the original `__salary`. The `vars()` function returns the `__dict__` of the object, which contains the mangled attribute name.

Answer

{'name': 'John'}

Answer

AttributeError: 'Employee' object has no attribute '__salary'

Answer

{'name': 'John', '__salary': 50000}

Question 15

Refer to the exhibit. What is the output when test.py is executed?

Accepted Answer

Parent
Child. super().hello() calls Parent.hello() which prints 'Parent', then the Child.hello() prints 'Child'.

Answer

Child
Parent

Answer

Parent

Answer

Child