PCAP Object-Oriented Programming Practice Test 1 — 15 Questions

Question 1

A developer wants to ensure that a class attribute is shared among all instances but cannot be modified from outside the class. Which approach is most appropriate?

Accepted Answer

Define a private class attribute (e.g., __shared) and provide a class method to access it. Defining a private class attribute with name mangling (e.g., `__shared`) prevents direct external modification, and providing a class method (using `@classmethod`) allows read-only access to the attribute. This ensures the attribute is shared among all instances (since it belongs to the class, not instances) while enforcing encapsulation.

Answer

Use a property decorator on a class method

Answer

Define a public class attribute and document it as read-only

Answer

Define an instance attribute inside __init__

Question 2

A team is developing a system that must handle different types of documents (PDF, Word, etc.). Each document type has a unique parsing method. To avoid massive conditional logic, which OOP concept should be applied?

Accepted Answer

Polymorphism. Polymorphism allows different document types (PDF, Word, etc.) to be treated uniformly through a common interface (e.g., a `parse()` method) while each class implements its own parsing logic. This eliminates the need for conditional statements (like `if type == 'PDF'`) because the correct method is resolved at runtime via dynamic dispatch, which is exactly what the team needs to avoid massive conditional logic.

Answer

Encapsulation

Answer

Inheritance

Answer

Abstraction

Question 3

A class 'MyClass' has a method 'do_something' that uses 'self.__private'. A subclass 'MySubClass' tries to access 'self.__private' and gets an AttributeError. Why?

Accepted Answer

Because name mangling renames the attribute to _MyClass__private, and the subclass implicitly accesses _MySubClass__private. Python's name mangling mechanism renames any attribute prefixed with double underscores (like `__private`) in a class definition to `_ClassName__private`. When `MySubClass` tries to access `self.__private`, Python looks for `_MySubClass__private`, which does not exist, causing an AttributeError. The attribute `_MyClass__private` is still accessible from the subclass, but only via its mangled name.

Answer

Because the attribute is defined as a class attribute, not instance attribute

Answer

Because the subclass overrides the method that uses the attribute

Answer

Because the attribute is private and not inherited

Question 4

A developer defines a class 'Car' with an attribute 'wheels = 4'. They create two instances: car1 = Car() and car2 = Car(). Then they set car1.wheels = 3. What is the value of car2.wheels?

Accepted Answer

4. In Python, setting an attribute directly on an instance (car1.wheels = 3) creates an instance attribute that shadows the class attribute for that specific instance only. The class attribute 'wheels = 4' remains unchanged and is still accessible via car2.wheels, which has not been overridden. Therefore, car2.wheels retains the class-level value of 4.

Answer

3

Answer

AttributeError

Answer

None

Question 5

A class 'Point' is defined with __slots__ = ['x', 'y']. A developer creates an instance p = Point() and tries to set p.z = 10. What happens?

Accepted Answer

AttributeError is raised. When a class defines `__slots__`, it restricts attribute assignment to only those names listed in the tuple. Attempting to assign an attribute not in `__slots__` raises an `AttributeError`. This is a deliberate memory optimization that prevents the creation of a per-instance `__dict__`, so dynamic attributes are disallowed.

Answer

The assignment is silently ignored

Answer

Python issues a warning and adds the attribute

Answer

The attribute 'z' is added dynamically

Question 6

A class 'Employee' has a method 'work()'. A subclass 'Manager' overrides 'work()' but also wants to call the parent's 'work()'. Which syntax correctly achieves this?

Accepted Answer

super().work(). In Python 3, super().work() is the recommended zero-argument form. super(Manager, self).work() is the older explicit form and still works correctly. Employee.work(self) directly calls the parent method and is also correct in single inheritance, though it bypasses the MRO. Since the question asks 'Which syntax correctly achieves this?' without restricting to 'best' or 'recommended', B, C, and D are all correct.

Answer

self.work()

Question 7

A developer defines a class 'A' with a method 'm' that uses 'self.a'. Class 'B' inherits from 'A' and defines __init__ that sets 'self.a = 10'. An instance of B is created and method m is called. What is the output?

Accepted Answer

10. When an instance of class B is created, its __init__ method sets self.a = 10. When method m (inherited from A) is called on that instance, self refers to the B instance, so self.a resolves to 10. Python's attribute lookup follows the instance's __dict__ first, finding the attribute set by B's __init__.

Answer

None

Answer

AttributeError

Answer

0

Question 8

A developer is designing a class hierarchy for a library system. They want to ensure that a method 'borrow' in the base class 'Item' can be overridden by subclasses like 'Book' and 'DVD', but the base implementation should not be callable directly. Which approach best achieves this?

Accepted Answer

Define borrow with raise NotImplementedError and override in subclasses. Raising `NotImplementedError` in the base class `Item.borrow` makes the method abstract in practice: it cannot be called directly without causing an error, forcing subclasses like `Book` and `DVD` to provide their own override. This pattern enforces that the base implementation is never invoked accidentally, while still allowing polymorphic dispatch through inheritance.

Answer

Define borrow as a static method and override in subclasses

Answer

Define borrow as a class method and override in subclasses

Answer

Define borrow with pass and let subclasses override

Question 9

A Python program uses multiple inheritance. Class A defines method 'foo', class B also defines 'foo', and class C(A, B) inherits from both. The developer expects that calling 'foo' on an instance of C should invoke the method from class A. However, it invokes the method from class B. What is the most likely cause?

Accepted Answer

The method resolution order (MRO) is not as expected due to the order of base classes. Python's MRO uses C3 linearization and respects the base class order as written. For class C(A, B), the MRO is C→A→B, so A.foo is found first. If B.foo is invoked, the most likely cause is that the developer actually wrote C(B, A), reversing the base class order. The question's premise is inconsistent unless the order is reversed.

Answer

Python always calls the method from the last base class

Answer

The 'foo' method in class B is defined after class A's 'foo' in the same file

Answer

Python uses depth-first, left-to-right resolution

Question 10

What is the output of the code?

Accepted Answer

20. The `Derived` class inherits the `get_x` method from the `Base` class, which returns `self._x`. When `obj.get_x()` is called, `self` refers to the `Derived` instance, and `self._x` accesses the `_x` attribute set in `Derived.__init__` (value 20). The `_x` attribute in `Derived` shadows the one in `Base`, so the output is 20.

Answer

AttributeError: 'Derived' object has no attribute 'get_x'

Answer

10

Answer

AttributeError: 'Derived' object has no attribute '_x'

Question 11

A developer wants to ensure that an attribute 'balance' of a BankAccount class cannot be accessed directly from outside the class but can be accessed through a method. Which approach should be used?

Accepted Answer

Declare 'self.__balance' and provide a getter method. Prefixing the attribute with double underscores (`__balance`) triggers Python's name mangling, which renames the attribute to `_BankAccount__balance` at runtime. This prevents direct access from outside the class (e.g., `obj.balance` raises an `AttributeError`), while a getter method (e.g., `get_balance()`) can still retrieve the value. This is the standard Python idiom for achieving 'weak' private encapsulation in OOP.

Answer

Declare 'self.balance' as a class variable

Answer

Declare 'self.balance' and provide a getter method

Answer

Declare 'self._balance' and provide a getter method

Question 12

An engineer is debugging an application that uses inheritance. The base class 'Vehicle' defines a method 'start()' that prints 'Vehicle started'. The subclass 'Car' overrides 'start()' to print 'Car started'. The code contains a function that accepts a Vehicle object and calls 'start()'. What is the output if a Car object is passed?

Accepted Answer

'Car started'. When a Car object is passed to a function expecting a Vehicle reference, Python uses dynamic dispatch (late binding) to call the overridden `start()` method defined in the Car class. Since the actual runtime type is Car, the overridden version executes, printing 'Car started'. This is a fundamental principle of polymorphism in Python.

Answer

'Car started Vehicle started'

Answer

'Vehicle started'

Answer

AttributeError

Question 13

During code review, a team member wrote: 'class Dog(Animal): pass'. The Animal class has an __init__ method that requires a 'name' parameter. When instantiating Dog, what should be done to properly initialize the inherited attributes?

Accepted Answer

Define __init__ in Dog that calls super().__init__(name). In Python, when a subclass like Dog inherits from a superclass like Animal, the __init__ method is not automatically called unless explicitly invoked. Since Animal's __init__ requires a 'name' parameter, Dog must define its own __init__ and call super().__init__(name) to ensure the inherited attributes are properly initialized. This follows Python's method resolution order (MRO) and is the standard pattern for cooperative multiple inheritance.

Answer

Define a new __init__ in Dog that does not call super

Answer

Dog will automatically inherit the __init__ method

Answer

Use a decorator to initialize

Question 14

A programmer writes a class with a static method using @staticmethod. What is the primary purpose of using a static method instead of a class method or instance method?

Accepted Answer

To define a method that does not depend on class or instance state and behaves like a regular function but is namespaced inside the class. A static method in Python, decorated with @staticmethod, does not receive an implicit first argument (neither self nor cls). This means it cannot access or modify class or instance state; it behaves exactly like a regular function but is organized within the class's namespace for logical grouping. The primary purpose is to encapsulate utility functions that are related to the class but do not depend on its data.

Answer

To access class variables without creating an instance

Answer

To allow the method to be overridden in subclasses

Answer

To enforce that the method cannot be called from an instance

Question 15

Consider the following code snippet: 'class A: pass; class B(A): pass; class C(A): pass; class D(B, C): pass'. What is the Method Resolution Order (MRO) for class D according to the C3 linearization algorithm used by Python?

Accepted Answer

D, B, C, A, object. The C3 linearization algorithm merges the linearizations of D's parents (B and C) with their parent list, respecting the local precedence order and monotonicity. For class D(B, C), the MRO is computed as D + merge(L(B), L(C), [B, C]), where L(B) = B, A, object and L(C) = C, A, object. The merge yields D, B, C, A, object, which is the correct MRO.

Answer

D, B, A, C, object

Answer

D, B, C, A

Answer

D, B, A, object, C