PCAP Object-Oriented Programming Practice Test 1 — 15 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__