PCAP Object-Oriented Programming — 10 Questions

Question 1

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 2

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 3

Which TWO of the following are valid ways to define a class attribute that is shared by all instances?

Accepted Answer

class MyClass: pass
MyClass.attr = 0. Assigning an attribute directly to the class after its definition (MyClass.attr = 0) creates a class-level attribute that is shared by all instances. Option D is correct because defining an attribute directly inside the class body (attr = 0) also creates a class-level attribute, accessible to all instances unless shadowed by an instance attribute.

Answer

class MyClass: attr: int = 0

Answer

class MyClass: def set_attr(self): MyClass.attr = 0

Answer

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

Question 4

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 5

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 6

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 7

Refer to the exhibit. What is the output?

Accepted Answer

2
2
2. The code defines a class `A` with a class variable `x = 2`, and a class `B` that inherits from `A`. The `display` method prints `self.x`, which first looks up the instance attribute `x`; since no instance attribute is set, it falls back to the class variable `x = 2` from class `A`. The loop creates three instances of `B` and calls `display` on each, so each prints `2` on a separate line, resulting in the output 2, 2, 2.

Answer

2
0
0

Answer

2
1
1

Answer

0
2
2

Question 8

Drag and drop the steps to create a Python package with subpackages into the correct order.

Accepted Answer

Create main package directory with __init__.py, then create subpackage directories with their own __init__.py, then place module files, then import using dot notation.. A package is a directory with __init__.py. Subpackages are subdirectories with their own __init__.py. Modules are placed inside, and imports use dot notation.

Answer

Create subpackage directories with their own __init__.py, then create main package directory with __init__.py, then place module files, then import using dot notation.

Answer

Create main package directory with __init__.py, then place module files, then create subpackage directories with their own __init__.py, then import using dot notation.

Answer

Import using dot notation, then create main package directory with __init__.py, then create subpackage directories with their own __init__.py, then place module files.

Question 9

Which of these is NOT a characteristic of Python's descriptor protocol?

Accepted Answer

Descriptors are only used for attributes that are read-only. Descriptors are not limited to read-only attributes; they can control get, set, and delete operations. A descriptor that only implements `__get__` is a non-data descriptor, which can be overridden by instance attributes, while a data descriptor implements both `__get__` and `__set__` (and optionally `__delete__`), allowing full read-write control. The statement that descriptors are only for read-only attributes is false, as they are commonly used for computed properties, validation, and lazy evaluation.

Answer

A descriptor can be used to create properties with custom behavior

Answer

Class variables assigned to a descriptor are automatically intercepted

Answer

A descriptor must implement __get__

Question 10

Which THREE statements about inheritance in Python are correct?

Accepted Answer

A child class inherits all attributes and methods from its parent class.. Option A is correct because in Python a subclass automatically inherits all non-private attributes and methods defined on its parent class, making them accessible on instances of the child. Option C is correct because Python natively supports multiple inheritance, allowing a class to derive from more than one base class (e.g., class C(A, B)), with the MRO (Method Resolution Order) resolving attribute lookups. Option E is correct because super() returns a proxy object that delegates method calls to the next class in the MRO, commonly used to invoke a parent's __init__ or overridden method. Option B is not correct because name-mangled private attributes (__name) are not truly inherited unchanged; they are mangled to _ClassName__name, so the child cannot access them by the original name. Option D is not correct because Python does not support compile-time method overloading based on parameter types or counts; defining a method with the same name simply overrides the previous one, and default arguments or *args/**kwargs are used instead.

Answer

Private attributes (with __) are inherited unchanged.

Answer

Python supports method overloading based on parameters.