PCAP Object-Oriented Programming — Timed 50 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

Question 16

A developer needs to create a class that cannot be instantiated directly but serves as a base for other classes. Which approach should be used?

Accepted Answer

Define the class using the ABCMeta metaclass and decorate methods with @abstractmethod. The correct approach is to use the abc module. Defining the class with ABCMeta and decorating at least one method with @abstractmethod makes the class abstract, preventing direct instantiation until a subclass overrides all abstract methods. This is the recommended way to create abstract base classes in Python. Raising NotImplementedError in __init__ is a common but less robust pattern and is not considered best practice for defining an abstract base class.

Answer

Define __init__ that raises NotImplementedError

Answer

Use a naming convention like _BaseClass

Answer

Define __new__ to return None

Question 17

Which TWO of the following are valid ways to define a class attribute (as opposed to an instance attribute) in Python?

Accepted Answer

class MyClass: attr = 5. Class attributes can be defined in two valid ways: directly inside the class body with `attr = 5` (option D), or by assigning to the class object after its definition with `MyClass.attr = 5` (option E). Both create data attributes shared by all instances. Options A and C create instance attributes, and B defines a method, not a data attribute.

Answer

obj.attr = 5 on an instance

Answer

class MyClass: def method(self): pass

Answer

class MyClass: def __init__(self): self.attr = 5

Question 18

Refer to the exhibit. Which THREE statements about the class hierarchy are correct?

Accepted Answer

Calling D().method() returns 'B'. When `D().method()` is called, Python's MRO (Method Resolution Order) for class D is `['D', 'B', 'C', 'A', 'object']`. Since class D does not define `method`, Python looks up the MRO and finds `method` first in class B. The `return 'B'` in B's `method` is executed, so the call returns 'B'.

Answer

D does not have a method named 'method'

Answer

The super() call in B would call C.method

Question 19

Refer to the exhibit. What will happen when the code is executed?

Accepted Answer

It raises an AttributeError. The code attempts to call a method or access an attribute that does not exist on the object. In Python, when you try to access an attribute or method that is not defined on an object, an AttributeError is raised. Option C is correct because the exhibit shows an attempt to call a non-existent method or attribute on an instance, which triggers AttributeError.

Answer

It prints None

Answer

It raises a TypeError

Answer

It prints 10

Question 20

Drag and drop the steps to define and call a function with default arguments in Python into the correct order.

Accepted Answer

Use the def keyword followed by the function name and parentheses
Specify parameters with default values using the assignment operator
Include a colon and indent the function body
Write the function body with statements that use the parameters
Call the function with only required arguments to use default values
Call the function with all arguments to override defaults. To define a function with default arguments in Python, first use the def keyword, then provide the function name and parentheses. Inside the parentheses, specify any parameters, optionally assigning default values using the assignment operator. Follow with a colon and indent the function body. Finally, call the function by its name, passing arguments as needed. The correct order is 1,2,3,4,5,6.

Answer

Call the function with all arguments to override defaults
Use the def keyword followed by the function name and parentheses
Specify parameters with default values using the assignment operator
Include a colon and indent the function body
Write the function body with statements that use the parameters
Call the function with only required arguments to use default values

Answer

Use the def keyword followed by the function name and parentheses
Specify parameters with default values using the assignment operator
Include a colon and indent the function body
Call the function with only required arguments to use default values
Write the function body with statements that use the parameters
Call the function with all arguments to override defaults

Answer

Use the def keyword followed by the function name and parentheses
Include a colon and indent the function body
Specify parameters with default values using the assignment operator
Write the function body with statements that use the parameters
Call the function with only required arguments to use default values
Call the function with all arguments to override defaults