PCAP Object-Oriented Programming Practice Test 2 — 15 Questions

Question 1

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 2

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 3

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 4

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 5

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

Question 6

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 7

Match each Python operator to its precedence level (1=highest).

Accepted Answer

**: Level 1 (highest). Operator precedence from highest to lowest: ** (exponent) > *, /, //, % (multiplicative) > +, - (additive).

Answer

*: Level 1

Answer

+: Level 2

Question 8

Match each list method to its effect.

Accepted Answer

append: Adds an element to the end of the list.. Common list methods: append adds an element to the end, extend adds all elements from an iterable, remove deletes the first occurrence of a value, pop removes an element by index, and sort arranges the list in ascending order by default.

Answer

pop: Removes the first occurrence of a specified value.

Answer

sort: Sorts the list in descending order.

Question 9

A developer is implementing a simple counter class. The class should start at 0 and increment by 1 each time the 'increment' method is called. Which implementation is correct?

Accepted Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1. It properly initializes an instance variable `self.count` to 0 in the `__init__` method and then uses `self.count += 1` in the `increment` method to modify the instance variable in place. The `+=` operator is a shorthand for `self.count = self.count + 1`, which correctly updates the counter each time `increment` is called.

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        count = self.count + 1

Answer

class Counter:
    def __init__(self):
        count = 0
    def increment(self):
        count += 1

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment():
        self.count += 1

Question 10

Consider the following class hierarchy: class A: def method(self): return 'A'; class B(A): pass; class C(A): def method(self): return 'C'; class D(B, C): pass. What is the output of D().method() according to Python's MRO?

Accepted Answer

'C'. Python's MRO (Method Resolution Order) for class D(B, C) is computed using the C3 linearization algorithm, which respects the local precedence order and monotonicity. The MRO for D is D -> B -> C -> A, so D().method() resolves to C.method(), returning 'C'. Option D is correct because C is the first class in the MRO that defines method().

Answer

'B'

Answer

TypeError

Answer

'A'

Question 11

A developer wants to ensure that the 'radius' attribute of a Circle class is always non-negative. Which implementation using @property is correct?

Accepted Answer

class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError
        self._radius = value. It uses the @property decorator to define a getter and @radius.setter to define a setter that validates the radius value before assignment. The __init__ method correctly assigns to self.radius, which triggers the setter, ensuring the initial value is also validated. This pattern enforces the invariant that radius is always non-negative.

Answer

class Circle:
    def __init__(self, radius):
        self._radius = radius
    def radius(self):
        return self._radius

Answer

class Circle:
    def __init__(self, radius):
        self._radius = radius
    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError
        self._radius = value

Answer

class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def radius(self):
        return self._radius
    def set_radius(self, value):
        self._radius = value

Question 12

A class MyClass defines __str__ and __repr__ methods. What is the purpose of __repr__?

Accepted Answer

To return an unambiguous representation of the object, ideally for debugging. The `__repr__` method is designed to return an unambiguous string representation of an object, ideally one that can be used to recreate the object or that clearly shows its internal state for debugging purposes. This is distinct from `__str__`, which targets end-user readability. The Python documentation explicitly states that `__repr__` should be unambiguous, while `__str__` should be readable.

Answer

To return a human-readable string for end users

Answer

To compare object equality

Answer

To return a hash value of the object

Question 13

Consider the following code: class A: x = 1; class B(A): pass; class C(A): x = 2; class D(B, C): pass. What is D.x?

Accepted Answer

2. Python's method resolution order (MRO) for class D, which uses multiple inheritance, follows the C3 linearization algorithm. The MRO for D is D, B, C, A, and since C defines x = 2, that attribute overrides the x = 1 from A in the inheritance chain, so D.x resolves to 2.

Answer

AttributeError

Answer

1

Answer

(1, 2) tuple

Question 14

A subclass overrides a method but wants to call the parent class's version. Which keyword should be used?

Accepted Answer

super(). In Python, the `super()` function is used to call a method from the parent class. When a subclass overrides a method, `super().method_name()` allows the subclass to invoke the parent class's implementation, enabling cooperative multiple inheritance and proper method resolution order (MRO). This is the correct keyword for accessing the parent class's version of an overridden method.

Answer

base

Answer

parent

Answer

self

Question 15

Which TWO statements about static methods (@staticmethod) are correct?

Accepted Answer

They do not receive an implicit first argument.. Static methods in Python do not receive an implicit first argument like `self` (for instance methods) or `cls` (for class methods). They behave like plain functions but belong to a class's namespace, and are called without any automatic parameter injection.

Answer

They can access instance attributes via self.

Answer

They can access class variables only via cls.

Answer

They can only be defined inside a metaclass.