PCAP Object-Oriented Programming Practice Test 5 — 15 Questions

Question 1

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 2

You are working on a legacy system that processes financial transactions. The system uses a class hierarchy: Transaction (base), Deposit, Withdrawal, Transfer. Each subclass overrides a method 'process()' to handle its specific logic. The code often runs in a multi-threaded environment and you notice intermittent errors where a transaction is processed twice. The logging shows that the same transaction object is being passed to the process method multiple times. The transaction objects are created from a factory function that caches recently used transactions. The errors seem to occur when two threads call the factory at the same time with the same parameters. After investigating, you find that the factory uses a class-level dictionary to cache objects. Which of the following is the most appropriate solution to prevent double processing?

Accepted Answer

Make the process() method idempotent by checking if the transaction has already been applied to the account (e.g., check balance changes). The core issue is that the same transaction object can be processed multiple times in a multi-threaded environment, even if the factory is fixed. Making process() idempotent by checking whether the transaction has already been applied (e.g., verifying account balance changes) ensures that repeated calls with the same object do not cause duplicate financial effects, directly addressing the symptom of double processing regardless of how the object is cached or retrieved.

Answer

Add a lock around the cache lookup and creation in the factory function

Answer

Add a flag to each transaction object to indicate if it has been processed, and check it at the start of process()

Answer

Remove the caching mechanism from the factory function to ensure new objects are always created

Question 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

Which of the following correctly uses an abstract base class to enforce that all subclasses implement a 'make_sound' method? (Assume ABC imported)

Accepted Answer

from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass. It imports both `ABC` and `abstractmethod` from the `abc` module, defines `Animal` as a subclass of `ABC`, and decorates `make_sound` with `@abstractmethod`. This combination prevents instantiation of `Animal` and forces any concrete subclass to override `make_sound`, or else a `TypeError` is raised at instantiation time.

Answer

from abc import abstractmethod
class Animal:
    @abstractmethod
    def make_sound(self):
        pass

Answer

class Animal:
    def make_sound(self):
        return None

Answer

class Animal:
    def make_sound(self):
        raise NotImplementedError

Question 12

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 13

Given: class A: def method(self): print('A'); class B(A): def method(self): super().method(); print('B'); class C(A): def method(self): super().method(); print('C'); class D(B, C): pass. What is printed by D().method()?

Accepted Answer

A C B. Python's MRO (Method Resolution Order) for class D, which inherits from B and C (both inheriting from A), follows the C3 linearization algorithm. The MRO for D is D -> B -> C -> A, so calling D().method() triggers B.method(), which calls super().method() (resolving to C.method()), which calls super().method() (resolving to A.method()), printing 'A', then back to C prints 'C', then back to B prints 'B', resulting in 'A C B'.

Answer

A B C

Answer

C A B

Answer

B A C

Question 14

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.

Question 15

Which TWO statements about Python's name mangling are correct?

Accepted Answer

The mangled name format is _ClassName__attribute.. Python's name mangling transforms an attribute name like `__attribute` defined in a class `MyClass` into `_MyClass__attribute`. This mechanism is specifically designed to avoid name clashes in subclasses, not to enforce privacy. The transformation is done by the compiler at definition time, not at runtime.

Answer

Name mangling applies to all method names that start with a single underscore.

Answer

Name mangling prevents external code from accessing the attribute entirely.

Answer

Name mangling occurs at runtime.