PCAP Object-Oriented Programming Practice Test 3 — 15 Questions

Question 1

A developer is implementing a caching system where object instances should be reused if they have the same set of initialization parameters. They want to control object creation so that calling MyClass(param1, param2) returns the same instance if it has been created before, otherwise creates a new one. They are considering overriding __new__ to implement this caching. However, they also need to ensure that __init__ is not called again for cached instances. What is the correct way to achieve this?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Override __call__ on the class metaclass.. To make MyClass(param1, param2) itself return cached instances without invoking __init__ on cache hits, override __call__ on the class's metaclass. The metaclass __call__ controls the class call syntax and can check a cache before creating a new instance. For new instances, it delegates to super().__call__() which runs __new__ and __init__. For cached instances, it returns the cached object directly, so __init__ is not called. Using a class method is a valid pattern but requires a different API (e.g., MyClass.get(...)), which contradicts the explicit 'calling MyClass(param1, param2)' requirement.

Answer

Override __new__ to return a cached instance, and override __init__ to do nothing if already initialized.

Answer

Use a class method as an alternative constructor and store instances in a class-level dictionary.

Answer

Override __new__ to return a cached instance if exists, and skip __init__ by checking if the instance is from cache.

Question 2

An application uses a heavy-weight class DatabaseConnection that establishes a network connection upon instantiation. The class is used in multiple places, and the developer wants to ensure that only one instance of DatabaseConnection exists throughout the application. They implement a Singleton pattern using a class attribute _instance and a class method get_instance(). However, they notice that the network connection is being established multiple times. After debugging, they find that the singleton is not being enforced because the __init__ method is called every time the class is instantiated, even if the same instance is returned. They want to fix this so that the connection is established only once. Which modification should they make?

Accepted Answer

Override __new__ in DatabaseConnection to control instance creation and return the singleton from there, bypassing __init__ on subsequent calls.. Overriding __new__ allows the developer to control instance creation at the lowest level. By checking if the singleton already exists in __new__, they can return the existing instance without calling __init__ again, thus preventing the network connection from being established multiple times. This is the standard Pythonic way to implement a singleton that avoids reinitialization.

Answer

Use the @staticmethod decorator on get_instance.

Answer

Use a global variable instead of a class attribute to store the singleton.

Answer

Move the connection initialization code out of __init__ and into a separate method that is called only once.

Question 3

Refer to the exhibit. What is the output?

Accepted Answer

4. The explanation claims a method call increments the instance attribute, but the expression shown (A().a + A.a) contains no method call. Based on the described class (class attribute a=1, instance a=2), the result would be 3, not 4. The missing exhibit is critical, and the explanation is internally inconsistent.

Answer

3

Answer

Error

Answer

A object

Question 4

Refer to the exhibit. What is the output?

Accepted Answer

10. Base.method returns 3*2=6, Derived.method adds 4, so 10.

Answer

7

Answer

Error

Answer

14

Question 5

Refer to the exhibit. What is the output?

Accepted Answer

1 2. '1 2'. When `print(A.x, a.x)` is executed, `A.x` accesses the class attribute `x=1`, and `a.x` accesses the instance attribute `x=2` (set in `__init__`), which shadows the class attribute for that instance. Therefore, the output is '1 2'.

Answer

1 1

Answer

0 1

Answer

2 2

Question 6

Refer to the exhibit. What is the output?

Accepted Answer

AttributeError. The code attempts to access an attribute that does not exist on the object. In Python, when you try to access an attribute that is not defined in the class or instance, the interpreter raises an AttributeError. Since the class does not have a method or property named 'x', calling obj.x triggers this exception.

Answer

0

Answer

None

Answer

10

Question 7

Refer to the exhibit. What is the output?

Accepted Answer

0 12.56. The Circle class has a class attribute pi=3.14 and an area method that returns pi * radius * radius. Two instances are created: c1 with radius=2 and c2 with radius=0. The code prints c2.area() followed by c1.area(), so the output is '0 12.56'. Therefore, option D is correct.

Answer

12.56 0

Answer

Error

Answer

0 0

Question 8

Refer to the exhibit. Which statement about the output is true?

Accepted Answer

a.__class__.__bases__ returns (,). `a.__class__` returns the class of instance `a`, which is `A`. Since `A` does not explicitly inherit from any class, it implicitly inherits from `object`. Therefore, `A.__bases__` returns `(,)`, which is exactly what `a.__class__.__bases__` evaluates to.

Answer

a.__class__.__bases__ returns an empty tuple

Answer

type(a).__bases__ returns (<class 'object'>,)

Answer

Both print statements output the same thing

Question 9

Refer to the exhibit. What is the output when test.py is executed?

Accepted Answer

Parent
Child. The exhibit (not shown here) depicts a Python script where a parent process prints 'Parent' and then spawns or forks a child that prints 'Child', with the parent's output appearing first. Given the expected ordering in the correct answer, the script executes the parent's print statement before the child's, producing 'Parent' followed by 'Child'. This matches the typical behavior when a parent process completes its print before the child process runs, or when using os.fork() with the parent continuing first.

Answer

Child
Parent

Answer

Parent

Answer

Child

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

1.0. The code defines a class attribute `version` with a value of `1.0`. The `__init__` method assigns the instance attribute `self.version` the value of the class attribute `MyClass.version` (which is `1.0`). When `obj.version` is accessed, Python first looks for an instance attribute; since `self.version` was set to `1.0` during initialization, it returns `1.0`. The class attribute remains unchanged.

Answer

0

Answer

AttributeError: type object 'MyClass' has no attribute 'version'

Answer

None

Question 11

A developer defines a class `Temperature` that stores a Celsius value in `self._celsius`. They also implement `__str__` to return a formatted string. When a `Temperature` instance is passed to `print()`, the output is not the formatted string but a default representation. What is the most likely cause?

Accepted Answer

The `__str__` method returns a non-string value, so Python falls back to the default representation.. `print()` calls `str()` on each argument, which invokes the object's `__str__` method if it exists. If `__str__` is defined but returns a non-string, Python raises a `TypeError` during printing, or if the method is missing or misnamed, the default representation is shown. The scenario indicates the formatted string is not used, so the likely cause is that `__str__` either returns a non-string or is not correctly defined.

Answer

The `__str__` method is defined with an incorrect indentation, so Python ignores it.

Answer

The `__str__` method is defined but `print()` uses `__repr__` instead when the object is an instance of a user-defined class.

Answer

The `__str__` method must be named `__repr__` to affect `print()` output.

Question 12

A developer defines `class Base:` with `def __init__(self, x): self.x = x`, then writes `class Derived(Base):` with its own `__init__` that must set an extra attribute `y` while still initialising `x`. Which TWO approaches correctly initialise the inherited attribute `x`? (Choose two.)

Accepted Answer

Call `super().__init__(x)` inside `Derived.__init__` before setting `self.y`.. Both `super().__init__(x)` and the explicit `Base.__init__(self, x)` call route through the base initialiser with the derived instance, so the inherited attribute is set by the code that owns it. The `super()` form follows the method resolution order and is preferred for cooperative multiple inheritance, while the explicit form works for a known single parent. Direct assignment duplicates logic, and Python never calls the parent initialiser automatically.

Answer

Define `x` as a class attribute on `Base` and skip the base initialiser entirely in `Derived`.

Answer

Assign `self.x = x` directly inside `Derived.__init__` without calling any base initialiser.

Answer

Rely on Python to invoke `Base.__init__` automatically before `Derived.__init__` runs.

Question 13

A developer creates a Python class with a method that is intended to be overridden in subclasses. Which approach best ensures that the method is not accidentally called on the base class?

Accepted Answer

Raise NotImplementedError inside the method body. Raising NotImplementedError inside the base class method is the standard Python idiom for defining an abstract-like method that must be overridden in subclasses. If a subclass fails to override the method and it is called, Python will raise an explicit error at runtime, preventing accidental use of the base implementation. This approach enforces the contract that the method is intended only for subclasses, without requiring the `abc` module.

Answer

Use 'pass' as the method body

Answer

Delete the method from the base class using 'del'

Answer

Add a comment '# override in subclass' inside the method body

Question 14

A developer wants to ensure that a class attribute is shared among all instances but cannot be modified from outside the class. Which approach is most appropriate?

Accepted Answer

Define a private class attribute (e.g., __shared) and provide a class method to access it. Defining a private class attribute with name mangling (e.g., `__shared`) prevents direct external modification, and providing a class method (using `@classmethod`) allows read-only access to the attribute. This ensures the attribute is shared among all instances (since it belongs to the class, not instances) while enforcing encapsulation.

Answer

Use a property decorator on a class method

Answer

Define a public class attribute and document it as read-only

Answer

Define an instance attribute inside __init__

Question 15

A Python class 'BankAccount' has a method 'withdraw(amount)' that deducts 'amount' from 'self.balance'. A developer writes a subclass 'SavingsAccount' that overrides 'withdraw' to add a penalty if balance drops below minimum. Which design pattern is being used?

Accepted Answer

Method overriding. Method overriding is the mechanism where a subclass provides a specific implementation of a method that is already defined in its superclass. In this scenario, SavingsAccount overrides the withdraw method from BankAccount to add penalty logic, which is the defining characteristic of method overriding in Python.

Answer

Composition

Answer

Aggregation

Answer

Inheritance