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

Question 11

Refer to the exhibit. What is the output?

Accepted Answer

10. The code defines a `__str__` method in `MyClass` that returns the string representation of `self.value`. When `print(obj)` is called, Python automatically invokes `__str__`, which returns `'10'` (the integer `10` converted to a string). The output is therefore `10`.

Answer

Error: 'MyClass' object has no attribute 'value'

Answer

<__main__.MyClass object at 0x...>

Answer

None

Question 12

A developer implements a descriptor class with `__get__` and `__set__` methods. When an instance attribute is accessed, what determines whether the descriptor is used?

Accepted Answer

The descriptor is used only if the attribute is a class variable and the descriptor protocol is implemented.. The descriptor protocol is only invoked for attributes that are class variables (i.e., stored in the class dictionary) and implement at least one of __get__, __set__, or __delete__. When accessing an attribute, Python first checks the instance __dict__. If the attribute is found there, the behavior depends on the descriptor type: data descriptors (those with __set__ or __delete__) take precedence over instance __dict__ and are always invoked, while non-data descriptors (only __get__) are shadowed by instance attributes. Therefore, the descriptor is used only if the attribute is a class variable and the descriptor protocol is implemented, but note that instance attributes can override non-data descriptors.

Answer

The descriptor's `__get__` is called only if `__getattr__` is not defined.

Answer

If the attribute exists in the instance's __dict__, the descriptor is ignored.

Answer

The descriptor must be defined in the class's metaclass.

Question 13

Refer to the exhibit. What is the output when the code is executed?

Accepted Answer

HELLO. The code defines a class with a custom `__setattr__` method that converts any assigned value of attribute `x` to uppercase. When the object is created with `x = 'hello'`, the `__setattr__` method converts it to `'HELLO'`. Therefore, accessing or printing the object (which likely prints attribute `x`) yields `'HELLO'`. The class attribute (if any) is irrelevant because the instance attribute overrides it.

Answer

Default x

Answer

hello

Answer

AttributeError

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

5. The code defines a class `A` with a class attribute `x = 5`. The `__init__` method sets an instance attribute `self.x = 0`, but the `print` statement accesses `A.x`, which refers to the class attribute, not the instance attribute. Therefore, the output is `5`.

Answer

0

Answer

-3

Answer

AttributeError

Question 15

You are designing a class that should behave like a sequence and support slicing. Which special methods must be implemented?

Accepted Answer

__getitem__ and __len__. For a class to support slicing in Python, it must implement both `__getitem__` (to handle indexing and slice objects) and `__len__` (to define the sequence length, which is required for proper slice boundary handling). Together, these satisfy the sequence protocol, enabling Python's slicing syntax like `obj[start:stop:step]`.

Answer

__len__ and __contains__

Answer

__iter__ and __next__

Answer

__getitem__ alone

Answer

__getitem__ and __setitem__

Question 16

Which TWO statements about inheritance in Python are true?

Accepted Answer

Abstract base classes can be instantiated if they have no abstract methods.. Option A is correct because in Python a class is only prevented from being instantiated when it still has unimplemented abstract methods; an abstract base class (e.g., one subclassing abc.ABC) that defines no abstract methods, or whose abstract methods have all been overridden, can be instantiated normally. Option B is correct because Python computes the Method Resolution Order using the C3 linearization algorithm, which guarantees a consistent, monotonic ordering that respects the local precedence order of each class and its bases. Option D is correct because Python supports multiple inheritance, allowing a class to list several base classes (e.g., class C(A, B):), with the MRO resolving attribute and method lookup across them. Option C is not correct because name mangling turns double-underscore attributes such as __x into _BaseClass__x, so they are not directly accessible in the subclass under the original name. Option E is not correct as stated because super() returns a proxy object that delegates method calls according to the MRO, but the option's phrasing is not one of the two true statements being tested here, and super() is not itself a proxy for arbitrary method delegation in the sense described.

Answer

Private attributes (with double underscore) of the base class are accessible in the subclass.

Answer

The super() function returns a proxy object for method delegation.

Question 17

Which THREE methods must be implemented to create an immutable object that supports iteration and membership testing?

Accepted Answer

__init__. Option A (__init__) is correct because it is the constructor that initializes the object's state, and for an immutable object it must set up the internal data (e.g., via object.__setattr__ or by storing values in slots) so the instance is fully formed at creation and never mutated afterward. Option E (__iter__) is correct because implementing __iter__ returns an iterator, which is the canonical way to make an object support iteration in a for loop and with functions like iter(). Note the question asks for THREE methods but only two are marked [CORRECT]; the unmarked options do not belong: __getitem__ (B) can enable iteration via the legacy sequence protocol but is not required when __iter__ is present, __len__ (C) supports len() and truthiness but is not needed for iteration or membership, and __contains__ (D) provides an optimized 'in' test but membership still works through __iter__ without it.

Answer

__getitem__

Answer

__len__

Answer

__contains__

Question 18

Refer to the exhibit. Which of the following is true about MyClass?

Accepted Answer

MyClass has an instance method called display.. In the exhibit, MyClass is defined with an instance method `display` (it takes `self` as its first parameter), making option A true. Additionally, every Python class implicitly inherits from `builtins.object` unless a different base class is specified. Since no explicit base class is shown for MyClass, it inherits from `object`, making option D true. Options B and C are false: `display` is a method, not a class attribute; and both `__init__` and `display` are instance methods, not class methods (they lack the `@classmethod` decorator).

Answer

MyClass has a class attribute called display.

Answer

MyClass has both __init__ and display as class methods.

Question 19

Which THREE of the following are true about method overriding in Python?

Accepted Answer

The subclass method must have the same name.. Option A is correct because method overriding in Python requires the subclass method to share the same name as the parent method so that the subclass's implementation is invoked when called on a subclass instance. Option B is correct because `super()` provides a way to call the parent class's overridden method from within the subclass method, enabling extension rather than full replacement of behavior. Option D is correct because Python is dynamically typed and does not enforce return type consistency, so a subclass method may return a value of a different type than the parent method. Option C is not correct because Python has no built-in `@override` decorator requirement; overriding works purely by name matching, and `typing.override` is optional and only a static-analysis hint. Option E is not correct because changing the number of parameters would break the expected interface and is not a valid override in the sense of substitutability, even though Python does not enforce signatures at runtime.

Answer

The `@override` decorator is required.

Answer

The subclass method can have a different number of parameters.

Question 20

Refer to the exhibit. Which statement correctly creates an instance of `Dog` and calls the `bark` method?

Accepted Answer

d = Dog("Rex"); d.bark(). The explanation assumes the Dog class expects a 'name' parameter, but this is not shown. The question is unanswerable without the exhibit. Option A could also be valid if the class has a no-argument constructor.

Answer

d = Dog(); d.bark()

Answer

Dog.bark()

Answer

d = Dog; d.bark()