CCNA Advanced Object Oriented Programming Questions

If `Plugin.__init_subclass__` is defined as `def __init_subclass__(cls):` without `**kwargs`, then the `priority=5` keyword is not consumed. Python then calls `super().__init_subclass__(**kwargs)` implicitly, ultimately reaching `object.__init_subclass__`, which raises TypeError for unexpected arguments. Adding `**kwargs` to the signature and forwarding it resolves the error.

__slots__ declares a fixed set of instance attributes, replacing the per-instance __dict__ with a compact slot descriptor array. This removes dictionary overhead, reducing memory usage per object and speeding attribute access, which is the stated purpose of defining __slots__.

Assigning to `t.celsius` invokes the property's setter function, which contains the validation logic. Since -300 is below absolute zero, the setter raises ValueError before modifying `self._celsius`, so the attribute keeps its previous value of 20. This is the intended use of properties to enforce invariants on attribute assignment.

When a subclass is created, Python automatically calls the parent's __init_subclass__ with the new class as the first argument. Defining it as a classmethod in the base class lets you capture that class and append it to a registry, achieving automatic registration without decorators.

`__str__` returns the informal, human-readable string representation, which `print()` and `str()` invoke for user-facing output. The alternative `__repr__` targets developers and aims for an unambiguous, ideally evaluable representation. The stem's constraint — informal, user-facing display — maps directly onto `__str__`, making it the responsible magic method.

Defining `__call__` on a class makes its instances callable, so `obj()` invokes that method directly — the exact behaviour the stem requires. Python resolves the call on the instance rather than the class, letting the object behave like a function while retaining its own state.

Defining `__eq__` without `__hash__` causes Python to set `__hash__ = None` on the class, marking instances as unhashable. Any attempt to use them in a set or as a dict key raises TypeError: unhashable type. To fix this, the developer must explicitly define `__hash__`, typically based on the same attributes used in `__eq__`.

An unrecognised type string means the factory cannot construct a valid product, so silently returning None would defer failure. Raising ValueError signals the invalid argument immediately at the call site, letting callers handle the unsupported request explicitly.

Python evaluates `v1 + 5` by calling `Vector.__add__(v1, 5)` first. Only if that returns the `NotImplemented` singleton does the interpreter try `int.__radd__(5, v1)`. Therefore `__radd__` cannot intercept the scalar case unless `__add__` explicitly yields `NotImplemented`, making a cooperative `__add__` essential to the design.

When a class defines `__eq__` without defining `__hash__`, Python implicitly sets that class's `__hash__` attribute to `None`, regardless of any `__hash__` inherited from a base class. Instances of `Discount` therefore cannot be hashed, and using one as a dictionary key raises `TypeError: unhashable type`. The inherited `Money.__hash__` does not save the subclass from this rule.

Class-level variables live on the class object itself and are therefore shared across every instance, whereas instance-level variables are stored per object in its __dict__. Assignment through an instance shadows rather than mutates the class attribute.

Defining `__iadd__` overrides the fallback to `__add__` for the `+=` operator. If `__iadd__` mutates the instance and returns `self`, the name `m1` is rebound to the same object, and its internal state changes. This exactly matches the observed behavior.

Accessing a missing attribute inside `__getattr__` re-invokes `__getattr__`, because the attribute lookup fails again, producing infinite recursion until Python raises `RecursionError`. Guard by raising `AttributeError` for unknown names or delegating to `super().__getattr__()`, satisfying the stem's requirement to avoid this pitfall.

In `ABCMeta.__new__(mcls, name, bases, namespace, **kwargs)`, the fourth positional parameter is the namespace dictionary containing all attributes defined in the class body. Accessing it before calling `super().__new__` lets the developer validate or modify attributes during class creation, exactly matching what the scenario requires.

During class creation the metaclass's __new__ receives the namespace dictionary containing all attributes defined in the class body, so reading it there exposes them before the class object exists. __init__ receives the already-built class instead, making __new__ the correct hook.

Defining __slots__ with 'x' and 'y' tells Python to allocate space for exactly those attributes in a compact structure, and the instance __dict__ is not created. Attempting to assign any other attribute raises AttributeError. This reduces memory overhead per instance.

super() follows the MRO, delegating to the next class in the linearised chain rather than a fixed parent, which enables cooperative multiple inheritance. Each class calls super() so sibling branches all execute exactly once, satisfying the stem's requirement for a true statement about multiple inheritance.

`__mul__` handles `v1 * 3` because the left operand is a `Vector`. For `3 * v1`, Python first tries `int.__mul__(3, v1)`, which returns `NotImplemented` because `int` does not know how to multiply by a custom type. Python then calls `Vector.__rmul__(v1, 3)`. Implementing both ensures both orders work and return a new `Vector`.

Using ABC and @abstractmethod makes Document uninstantiable and forces subclasses to implement render() before they can be instantiated. This is the standard, explicit way to define an abstract base class in Python. Any subclass that does not override render() remains abstract and raises TypeError on instantiation, precisely matching the requirement to force implementation and prevent direct instantiation.

Without a default, getattr raises AttributeError when the named attribute is absent from the object. That unhandled exception is the primary risk, since callers must anticipate and catch it rather than receiving a fallback value.

A class defining `__call__` receives the function being decorated as its initialiser argument, storing it for later invocation. This satisfies the stem's requirement: the decorator object wraps the target function, then `__call__` intercepts subsequent calls, forwarding arguments and returning the wrapped result.

__init__ initialises an already-created instance in place, so it must return None; returning any other value raises TypeError. Object construction itself is handled by __new__, which allocates and returns the instance, so __init__ has nothing meaningful to return.

`a += b` invokes `Vector.__iadd__`, which mutates `self` and returns it. Because `c = a` binds `c` to the same object, the in-place mutation is visible through `c`. This aliasing effect is the defining behavior of in-place operators and can surprise developers who expect `+=` to rebind a new object.

Observers registered with a subject via strong references keep each other alive, so unregistered observers are never collected. weakref holds observers without incrementing their reference count, letting garbage collection reclaim them and preventing the memory leaks that accumulate over long-lived subjects.

Using only the `@property` decorator creates a read-only attribute: the getter runs on access, but any assignment raises `AttributeError` because no setter exists. This directly satisfies the stem's read-only constraint, unlike a plain attribute, which remains freely writable.

`__str__` supplies the informal, human-readable string that `print()` calls when converting an instance to text. Python's `print()` invokes `str()` on its arguments, which delegates to `__str__`; `__repr__` only serves as a fallback when `__str__` is undefined. This directly satisfies the stem's requirement for controlling printed output.

`WeakSet` stores weak references, so when an observer object has no other strong references, it is collected and the set entry disappears silently. This is precisely the behavior wanted for the Observer pattern to avoid keeping observers alive indefinitely. No manual unregistration is required for objects that go out of scope.

Observers register callbacks with the subject rather than being invoked by name, so the subject holds no compile-time reference to concrete observer classes. This satisfies the stem's decoupling constraint, letting observers be added or removed at runtime.

__set_name__ is called automatically at class creation with the owner class and the attribute name, letting the descriptor capture its own identifier. This removes the need to pass the name manually, enabling descriptors to store or validate per-attribute data.

super() delegates to the next class in the method resolution order rather than a hard-coded parent, so cooperative multiple inheritance chains correctly. This satisfies the stem's requirement by avoiding the brittle, MRO-breaking direct parent call.

Calling `type(name, bases, dict)` invokes the three-argument metaclass constructor, which builds a fresh class object at runtime from the supplied name string, base-class tuple and namespace dictionary. This satisfies the stem's requirement precisely: the three-argument form exists to create classes dynamically, unlike the single-argument form that merely returns an object's type.

The @abstractmethod decorator marks a method as abstract within an ABC, so any concrete subclass that does not override it cannot be instantiated; Python raises TypeError at instantiation. This enforces the subclass implementation the question describes.

Inheriting an ABC without overriding every abstract method leaves the subclass abstract, so Python refuses instantiation and raises TypeError. This satisfies the stem's constraint: the missing implementation is detected at instantiation time, not at class definition, because ABCMeta records remaining abstract methods in `__abstractmethods__`.

Skipping super().__init__() breaks Python's cooperative multiple-inheritance chain: the MRO traversal halts at that class, so subsequent parent initialisers never execute. This satisfies the stem's constraint that later classes in the MRO remain uninitialised, leaving their instance attributes unset.

`__del__` is the destructor magic method invoked when an object's reference count reaches zero or the interpreter shuts down, satisfying the stem's requirement for deletion via `del`. Note that `del` removes a reference rather than guaranteeing immediate finalisation, so `__del__` may run later under cyclic references.

The `@staticmethod` decorator wraps the function in a descriptor that returns the plain function without binding `self` or `cls`, so metaclass interference is irrelevant. Metaclasses control class creation, not instance attribute lookup, so the static method resolves correctly on both the class and its instances.

__add__ is called for the + operator and should return a new Temperature instance. __eq__ is called for == and should compare the underlying values. Implementing these two methods provides the required behavior. Without __add__, + would raise TypeError; without __eq__, == would fall back to identity comparison, which is not desired.

Omitting __slots__ in the child reinstates a per-instance __dict__, so the parent's memory optimisation no longer applies to child instances. The child still inherits the parent's slot descriptors, but new attributes are stored in the dictionary, satisfying the scenario where the subclass defines no __slots__.

A `property` intercepts attribute access through descriptor protocol methods, so the setter can validate before writing to an internal field such as `_celsius`. Reads remain transparent because the getter simply returns the stored value. This keeps the public name `celsius` while enforcing the constraint at assignment time, which is exactly the requested behavior.

`sum()` begins with `0` and adds each element. The first operation is `0 + m1`, which calls `int.__add__(0, m1)` and returns `NotImplemented` because `int` cannot add a `Matrix`. Python then tries `Matrix.__radd__(m1, 0)`. If `__radd__` is not defined, a `TypeError` is raised. Implementing `__radd__` to handle the initial `0` (or any non-Matrix) fixes the issue.

A Singleton holds its instance in a shared, globally reachable location, so every consumer reads and writes the same state. This introduces global state, creating hidden coupling and making tests order-dependent and hard to isolate.

Raising `NotImplementedError` in the base method is a widely used convention that surfaces missing overrides at runtime when the method is called. It does not prevent instantiation, but it does enforce that subclasses provide their own implementation to avoid the exception. This is valid though less strict than ABC-based enforcement.

Constructor injection lets the context hold a reference to an abstract strategy object, so algorithms are selected at runtime without subclassing the context. This satisfies the pattern's requirement of interchangeable behaviour, since swapping the passed instance changes the algorithm while the context's interface stays fixed.

The @final decorator from typing marks the method so type checkers flag any subclass override, satisfying the requirement to prevent overriding. At runtime it does not enforce, but it is the documented, idiomatic mechanism for declaring a method non-overridable in a hierarchy.

`ABCMeta` tracks unimplemented abstract methods. When `Circle` does not override `area`, its `__abstractmethods__` set still contains `'area'`, and calling `Circle()` triggers `TypeError: Can't instantiate abstract class Circle with abstract method area`. This is exactly the enforcement `@abstractmethod` provides.

Python always calls `__init__` on the object returned by `__new__` if it is an instance of the class. A class-level boolean flag set after the first initialization lets `__init__` skip reinitialization on later calls, preserving the singleton's state. This is the standard, explicit way to prevent repeated initialization while still returning the same object.

Including `'__dict__'` in `__slots__` reserves a per-instance dictionary in addition to the slot descriptors. Instances still get fast slot storage for `host` and `port`, but also accept arbitrary new attributes like `timeout`. This is the documented way to opt back into dynamic attributes while retaining slots for the declared names.

Using `super()` in each class delegates along Python's C3 linearisation, so every sibling in the diamond is invoked exactly once in method resolution order. This satisfies the stem's requirement to reach a sibling class without duplicating the shared base, which direct base-class calls would trigger.

The context manager protocol requires the class to implement __enter__, invoked on entry to the with block, and __exit__, invoked on exit. Without both methods defined, Python raises AttributeError, so this is a genuine requirement of the with statement's protocol.

A concrete factory implements the abstract creation interface declared by the factory, returning concrete product instances for a specific variant. This lets client code request products through the shared interface while remaining decoupled from the concrete classes.

Python caches imported modules in sys.modules, so a module-level instance is created once at import and shared thereafter. This gives singleton behaviour with no metaclass, __new__ override or locking, satisfying the pattern with less code.

The `__repr__` method returns an unambiguous string representation of an object, intended primarily for developers and debugging. Unlike `__str__`, which prioritises readability for end users, `__repr__` should ideally produce output that could recreate the object, satisfying the requirement for precise, diagnostic output.

ABCMeta intercepts instantiation of classes using abstractmethod, raising TypeError when any abstract method remains unimplemented. This enforces the contract at object creation time, rather than merely documenting it, which is the enforcement the abc module exists to provide.

When evaluating 5 + amount1, Python first tries int.__add__(5, amount1), which returns NotImplemented because int does not know Money. It then tries Money.__radd__(amount1, 5). If __radd__ is not defined, Python raises TypeError. Meanwhile amount1 + amount2 and amount1 + 5 work via __add__. This matches the required behavior exactly.

Without redeclaring __slots__ in the subclass, Python reinstates a __dict__ on instances, silently negating the memory savings the parent achieved. This is the classic inheritance pitfall, so subclasses must repeat the declaration to preserve the slot-only layout.

A strong reference held by the subject keeps each observer alive, so reference counting never reaches zero and the garbage collector cannot reclaim observers that are no longer needed. Weak references let them be collected once external references disappear.

A classmethod binds to the class and passes it implicitly as the first argument (conventionally `cls`), so it can access or modify class state and works correctly with inheritance. A staticmethod receives no implicit first argument, behaving as a plain function namespaced inside the class. This directly satisfies the stem's request for the primary distinction.

`__getitem__` is the magic method Python invokes for subscription syntax, so defining it lets instances respond to `obj[i]` with square brackets. It satisfies the stem's index-access constraint directly, unlike `__getattr__`, which handles attribute lookup, or `__iter__`, which drives iteration protocols.

Magic methods such as __add__, __eq__ and __len__ are invoked implicitly by Python's syntax and built-in operations, letting user classes integrate with operators, iteration and context managers. This hook mechanism is exactly what the stem asks about, rather than naming conventions or inheritance behaviour.

Overriding `__new__` in a base class lets you intercept instantiation before `__init__` runs, returning the same cached instance on every call. This satisfies the singleton constraint by centralising instance control in one reusable parent, so subclasses inherit the behaviour without duplicating logic.

`__init_subclass__` is an implicit classmethod invoked on the parent class immediately after each subclass is created, receiving the new class as its first argument. It runs automatically at class-definition time, so no explicit registration call is needed in the subclass body. Because it is just a normal method, it composes cleanly with `ABCMeta` instead of replacing or conflicting with it.

Python's binary operator protocol dispatches addition to the left operand's type: evaluating a + b invokes type(a).__add__(a, b). Since the class defines __add__, that method executes, receiving self and the other operand, and its return value becomes the expression's result.

A metaclass's `__call__` intercepts instantiation of the class it builds, running when you call the class to create an instance. It satisfies the stem's constraint by executing at instance-creation time, before `__init__` and `__new__` of the class itself, allowing the metaclass to customise or replace the returned object.

Defining `__contains__` on a class lets Python delegate membership tests to it, so `x in instance` invokes your logic instead of falling back to iteration via `__iter__` or `__getitem__`. This directly customises the `in` operator's behaviour, satisfying the stem's requirement precisely.

The with statement calls __enter__ on entry and __exit__ on exit, the latter receiving exception details for cleanup or suppression. Implementing both satisfies the stem's context manager requirement, since neither method alone enables the protocol.

`isinstance()` accepts an object and a class (or tuple of classes) and returns a Boolean, resolving the object's type through its class hierarchy, including inherited and virtual subclasses. This directly satisfies the stem's requirement to check whether an object is an instance of a class, unlike identity or equality comparisons.

A registry maps product identifiers to creator callables, so new products register themselves at import time. This satisfies the open/closed constraint: the factory function stays untouched, eliminating the if-else chain that would otherwise require editing whenever a product type is added.

`__init_subclass__` runs automatically on subclass creation without a separate metaclass, so it satisfies the stem's need to hook subclassing while avoiding metaclass conflicts. It is a plain classmethod on the parent, simpler to implement than a metaclass, and coexists with any existing metaclass.