PCPP1 Advanced Object Oriented Programming Practice Test 5 — 15 Questions

Question 1

When using a metaclass, how can you access the class attributes during the class definition?

Accepted Answer

By accessing the namespace dictionary passed to __new__.. The class dictionary passed to the metaclass's __new__ method contains all the attributes defined within the class body.

Answer

By calling super().

Answer

By accessing the class __dict__.

Answer

By querying the base class.

Question 2

You are designing a plugin system where each plugin class must automatically register itself with a central registry when defined, without requiring an explicit decorator or registration call. You decide to use the __init_subclass__ hook in the base Plugin class. Which statement correctly describes how to implement this so that every subclass is registered with its own class object?

Accepted Answer

Define __init_subclass__ as a classmethod in the base class that receives the new subclass as its first argument and adds it to a registry list.. The __init_subclass__ hook is invoked automatically on the parent class whenever a subclass is defined, receiving the new subclass as an argument. Implementing it as a classmethod in the base Plugin class allows the base to append each subclass to a shared registry at definition time, satisfying the automatic registration requirement without decorators or manual calls.

Answer

Define __init_subclass__ as an instance method in the base class that receives self and uses type(self) to identify the subclass.

Answer

Override __new__ in the base class to intercept subclass creation and register the subclass there.

Answer

Use a metaclass with a __call__ method that registers the class when the first instance is created.

Question 3

You are designing a class `Matrix` that supports element-wise addition and scalar multiplication. You want `m1 + m2` to return a new `Matrix` without modifying `m1` or `m2`. You have implemented `__add__` correctly. A colleague writes `m1 += m2` and expects `m1` to be rebound to a new `Matrix` object. However, after the statement, `m1` still refers to the same object and its internal data has been modified in place. Which change to your class is the most likely cause of this behavior?

Accepted Answer

You defined `__iadd__` to call `__add__` and then return `self` after updating the internal list in place.. The augmented assignment `+=` first looks for `__iadd__` on the left operand. When `__iadd__` is defined and mutates the object before returning `self`, the name is rebound to the same object and the original data changes. Without `__iadd__`, Python falls back to `__add__`, which produces a new object and rebinds the name.

Answer

You defined `__iadd__` to return a new `Matrix` instance without modifying `self`.

Answer

You defined `__radd__` to return a new `Matrix` instance instead of `NotImplemented`.

Answer

You defined `__add__` to modify `self` in place and return `self`.

Question 4

You are implementing a class that represents a monetary amount. You want the expression amount1 + amount2 to return a new Money instance, and you also want amount1 + 5 to work by treating 5 as a Money with zero cents. However, 5 + amount1 should raise a TypeError. Which implementation achieves this behavior?

Accepted Answer

Define only __add__(self, other) to handle Money and int, and do not define __radd__.. For amount1 + amount2 and amount1 + 5, Python calls Money.__add__, which can handle both Money and int. For 5 + amount1, int.__add__ returns NotImplemented, and Python then looks for Money.__radd__. Since __radd__ is not defined, a TypeError is raised. This precisely implements the asymmetric addition behavior required.

Answer

Define __add__(self, other) and __radd__(self, other) where __radd__ simply calls self.__add__(other).

Answer

Define __iadd__(self, other) to handle both Money and int, and rely on Python to fall back to __add__ for the + operator.

Answer

Define __add__(self, other) to handle both Money and int, and define __radd__ to raise TypeError.

Question 5

A developer creates a class named `Registry` in a module. The class inherits from `ABCMeta` and defines a `__new__` method that performs validation on the class namespace before the class is created. Inside `__new__`, the developer needs to inspect the attributes defined in the class body of the class being created. Which parameter of `__new__` provides direct access to those attributes?

Accepted Answer

The `namespace` parameter.. The namespace dictionary is the fourth positional argument supplied to `ABCMeta.__new__`. It holds every name bound in the class body before the class object exists, which is exactly the data needed for validation during class creation. The other parameters describe the metaclass, the parent tuple, or extra keywords, none of which carry class-body attributes.

Answer

The `bases` parameter.

Answer

The `**kwargs` parameter.

Answer

The `mcls` parameter.

Question 6

You are designing a class `Connection` that must ensure only one instance exists and that the same instance is returned whenever `Connection()` is called. You implement this using `__new__` to control instance creation, and you also define `__init__`. During testing, you notice that `__init__` runs every time `Connection()` is called, even though `__new__` returns the existing singleton instance. What is the most appropriate way to prevent `__init__` from reinitializing the singleton on subsequent calls?

Accepted Answer

Use a class-level flag to track initialization and guard the `__init__` logic.. When `__new__` returns an existing instance, Python still calls `__init__` on it. To avoid reinitialization, the class must explicitly track whether initialization has already occurred. A class-level flag checked at the start of `__init__` is the simplest, most readable solution. It preserves the singleton's state and avoids side effects from repeated setup, which is critical for resources like connections.

Answer

Delete the `__init__` method so only `__new__` runs.

Answer

Use a metaclass to override `__call__` and cache the instance.

Answer

Override `__new__` to return `None` when an instance already exists.

Question 7

You are creating a class where you want to prevent instances from having a __dict__ to save memory. You add __slots__ = ('x', 'y') to the class. Which statement is true about this class?

Accepted Answer

Instances of the class will not have a __dict__ and can only have attributes x and y.. The __slots__ declaration restricts instances to the named attributes and eliminates the per-instance __dict__, saving memory. Only attributes listed in __slots__ can be assigned; others raise AttributeError. Subclasses do not automatically inherit this restriction unless they also define __slots__.

Answer

The class can still accept arbitrary attributes, but they will be stored in a separate dictionary.

Answer

Instances will still have a __dict__, but x and y will be stored in slots for faster access.

Answer

Subclasses of this class will also be prevented from having a __dict__ automatically.

Question 8

You are designing a class hierarchy for a document processing system. The base class `Document` defines a method `render()` that returns a string. You want subclasses to be forced to provide their own implementation, and you want to prevent `Document` from being instantiated directly. Which code correctly enforces this requirement?

Accepted Answer

from abc import ABC, abstractmethod

class Document(ABC):
    @abstractmethod
    def render(self):
        pass. The abstract base class pattern with ABC and @abstractmethod is the idiomatic way to prevent direct instantiation of a base class and force subclasses to implement specific methods. It ensures that any subclass lacking an override remains abstract and cannot be instantiated, raising a TypeError. The other approaches either fail to enforce implementation or rely on fragile runtime checks.

Answer

class Document:
    def render(self):
        raise NotImplementedError("Subclass must implement render")

def __init__(self):
        if self.__class__ is Document:
            raise TypeError("Cannot instantiate Document directly")

Answer

class Document:
    def render(self):
        pass

def __new__(cls, *args, **kwargs):
        if cls is Document:
            raise TypeError("Cannot instantiate Document directly")
        return super().__new__(cls)

Answer

class Document:
    def render(self):
        raise Exception("Not implemented")

class DocumentMeta(type):
    def __call__(cls, *args, **kwargs):
        if cls is Document:
            raise TypeError("Cannot instantiate Document directly")
        return super().__call__(*args, **kwargs)

Question 9

A developer defines a class `Temperature` that stores a Celsius value in `self._celsius` and exposes a `celsius` property with a setter that validates the value is not below absolute zero. After instantiating `t = Temperature(20)`, the developer runs `t.celsius = -300`. What happens?

Accepted Answer

The setter runs, detects the invalid value, and raises a ValueError; `t._celsius` remains 20.. The property setter is invoked on assignment to `t.celsius`, and its validation logic rejects -300. Because the exception is raised before `self._celsius` is updated, the original value remains intact. This demonstrates how properties enforce encapsulation and invariants without changing the public attribute name.

Answer

A TypeError is raised because `t.celsius` is read-only once the property is defined without a deleter.

Answer

The assignment silently succeeds and `t.celsius` returns -300 because properties only intercept reads, not writes.

Answer

Python bypasses the setter because `_celsius` is a private attribute and assigns -300 directly to `t._celsius`.

Question 10

You are implementing a class `Vector` that supports addition and scalar multiplication. You want `v1 + v2` to return a new `Vector`, and `v1 * 3` to return a new scaled `Vector`. You also want `3 * v1` to work identically. Which pair of methods must you implement to support both `v1 * 3` and `3 * v1` correctly, assuming `v1` is a `Vector` and `3` is an `int`?

Accepted Answer

`__mul__` and `__rmul__`. To support both `v1 * 3` and `3 * v1`, the class must define `__mul__` for the normal case and `__rmul__` for the reflected case. When the left operand's `__mul__` returns `NotImplemented`, Python tries the right operand's `__rmul__`. Implementing both ensures consistent behavior regardless of operand order, which is important for intuitive mathematical types.

Answer

`__rmul__` and `__radd__`

Answer

`__mul__` only, because Python automatically swaps operands.

Answer

`__mul__` and `__imul__`

Question 11

A developer wants to ensure that a method `area` in a base class `Shape` must be overridden by any concrete subclass. The developer writes `class Shape(ABC):` and `@abstractmethod def area(self): ...`. A colleague then creates `class Circle(Shape):` without implementing `area` and tries to instantiate `Circle()`. What happens?

Accepted Answer

A `TypeError` is raised at instantiation time because `Circle` still has abstract methods.. The `ABCMeta` metaclass maintains a set of abstract method names on each class. A subclass that does not override all of them keeps a non-empty set, and instantiation raises `TypeError`. The `...` body is irrelevant because the abstract method is never invoked; enforcement happens before the object exists.

Answer

`Circle()` succeeds and `area()` returns `None` because the base method body is `...`.

Answer

`Circle()` succeeds, and calling `area()` later raises `NotImplementedError`.

Answer

A `SyntaxError` is raised when the `Circle` class definition is parsed.

Question 12

A library defines a base class `Plugin` with `__init_subclass__(cls, **kwargs)` that automatically registers every subclass in a global registry using `cls.__name__`. A developer writes `class MyPlugin(Plugin, priority=5): pass` but the registration fails with a TypeError about unexpected keyword arguments. What is the most likely cause?

Accepted Answer

The base `Plugin.__init_subclass__` signature does not accept or forward `**kwargs`, so `priority=5` reaches `object.__init_subclass__`, which rejects it.. Keyword arguments in a class header are forwarded to the parent's `__init_subclass__`. If that method does not declare `**kwargs` and forward them, the extra keyword reaches `object.__init_subclass__`, which rejects it with TypeError. Adding `**kwargs` to the signature and passing them to `super().__init_subclass__(**kwargs)` fixes the registration.

Answer

`__init_subclass__` must be declared as a classmethod explicitly; otherwise keyword arguments are not forwarded.

Answer

The registry is full because `__init_subclass__` runs before the class body executes, so `cls.__name__` is not yet available.

Answer

Keyword arguments passed in a class definition header are only supported on metaclasses, not on `__init_subclass__`.

Question 13

A developer defines `class Config:` with `__slots__ = ('host', 'port')`. Later, they want to add a new attribute `timeout` to an existing instance without modifying the class. They write `cfg.timeout = 30` and receive an `AttributeError`. Which change would allow per-instance `timeout` assignment while keeping `__slots__` for `host` and `port`?

Accepted Answer

Add `'__dict__'` to `__slots__`.. Slot descriptors are the only writable attributes unless the class also provides a `__dict__`. Declaring `'__dict__'` inside `__slots__` creates that dictionary, so new names like `timeout` can be stored per instance while `host` and `port` remain fast slots. The other options either do not affect assignment or misuse the `__slots__` contract.

Answer

Add a `__getattr__` method that returns `30` for unknown names.

Answer

Subclass `Config` and add `__slots__ = ()` in the subclass.

Answer

Change `__slots__` to a dictionary mapping names to default values.

Question 14

A developer writes a class `Money` that implements `__eq__` to compare amounts and currencies, but does not implement `__hash__`. Instances of `Money` are then used as keys in a `set`. What is the result?

Accepted Answer

A TypeError is raised when adding an instance to the set because the class is unhashable.. Python disables the inherited `__hash__` when a class overrides `__eq__`, because equal objects must have equal hashes for hash-based collections to work correctly. The developer must define `__hash__` explicitly, hashing the same attributes used in `__eq__`, so that equal `Money` instances produce identical hashes and can be stored in sets or dicts.

Answer

Instances are hashed using the hash of their `__dict__`, so two equal `Money` objects collapse into one set element.

Answer

The set stores instances by identity, so duplicates are allowed and no error occurs.

Answer

Instances can be added to a set, and equality is used for deduplication because `__hash__` defaults to `id()`-based hashing.

Question 15

You are designing a plugin registry that must automatically register every concrete subclass of a base class `Plugin` at the moment the subclass is defined, without requiring any explicit registration call in the subclass body. You want to avoid a metaclass because the project already uses `ABCMeta` for the base class and you do not want to introduce metaclass conflicts. Which approach best satisfies this requirement?

Accepted Answer

Define `__init_subclass__` as a classmethod on `Plugin` that appends the newly created class to a registry list.. The implicit `__init_subclass__` classmethod is executed by Python on the parent class right after a subclass is created, so it provides exactly the definition-time hook the registry needs. It is a plain method, so it coexists with `ABCMeta` and other metaclasses without conflict. Hooks tied to instantiation or descriptor binding run at the wrong moment and cannot reliably capture every concrete or abstract subclass.

Answer

Use `__subclasses__()` on `Plugin` inside a periodic background thread and append any newly discovered subclasses to the registry.

Answer

Override `__set_name__` on `Plugin` so that each subclass reports its name to the registry when the class body finishes executing.

Answer

Define `__new__` on `Plugin` and insert the class into the registry whenever `Plugin` itself is instantiated.