Advanced Object Oriented Programming

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?

Which of the following describes the purpose of the __slots__ attribute in a class?

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?

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?

Which magic method is responsible for providing the informal string representation of an object, typically used for user-facing output?

Which magic method allows an object to behave like a function?

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?

In the Factory pattern, what should you do if the requested type is unknown?

You are implementing a `Vector` class whose instances should support `v1 + v2` and also `v1 + 5`, where the second form broadcasts the scalar across every component. A colleague suggests relying on `__radd__` to handle the scalar case. Why is that insufficient?

A teammate writes a `Money` value object that defines `__eq__` to compare amounts and currencies, and `__hash__` to hash the same two fields. During a code review you notice that a subclass `Discount` adds a `percentage` field, overrides only `__eq__` to include that field, and leaves `__hash__` inherited. Objects of `Discount` are then used as dictionary keys. What is the actual runtime consequence?

What is the difference between a class-level variable and an instance-level variable?

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?

When overriding the __getattr__ method, what must you be careful to avoid?

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?

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

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?

Which TWO of the following are true regarding multiple inheritance in Python?

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`?

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?

What is the primary risk of using 'getattr' without a default value?

When using the __call__ method to implement a decorator, what does the decorator receive as an argument?

Why does the __init__ method not return anything?

A developer implements a class `Vector` with `__add__` returning a new `Vector`, and also defines `__iadd__` that mutates `self` in place and returns `self`. A colleague writes `a = Vector(1,2); b = Vector(3,4); c = a; a += b`. What is the state of `c`?

What is the purpose of the 'weakref' module in relation to the Observer pattern?

How do you define a property in a class to make it read-only?

Which magic method is used to control how an instance is displayed when using the print() function?

A developer is implementing the Observer pattern and wants to store a list of observers without preventing them from being garbage collected when no other references exist. They decide to use `weakref.WeakSet` to hold the observers. Which statement accurately describes the behavior they should expect?

In the context of the Observer pattern, what is the benefit of an event-driven system over a direct-method-call approach?

What is the purpose of the __set_name__ method in descriptors?

Why should you use super() instead of calling the parent class method directly by name?

What is the purpose of the 'type' function when called with three arguments?

What does the @abstractmethod decorator do when applied to a method inside an ABC?

When using abstract base classes (ABCs) from the abc module, what happens if a class inherits from an ABC but fails to implement one of the abstract methods?

What is the consequence of not calling super().__init__() in a class with multiple inheritance?

Which magic method is triggered when an object is deleted using the 'del' keyword?

What is the result of applying the @staticmethod decorator to a method inside a class that also defines a metaclass?

You are writing a class `Temperature` that should support addition and comparison. You want `t1 + t2` to return a new `Temperature` object, and `t1 == t2` to compare their values. Which magic methods must you implement to achieve this?

What is the effect of setting __slots__ in a parent class on a child class that does not define its own __slots__?

A `Temperature` class stores a numeric `celsius` attribute. Callers keep assigning `temp.celsius = -500`, which is physically impossible. You want any assignment below absolute zero to raise `ValueError` while keeping normal attribute access unchanged. Which construct should you implement?

You are implementing a class `Matrix` that supports the `+` operator for matrix addition. You want `m1 + m2` to return a new `Matrix`, and you also want `sum([m1, m2, m3])` to work correctly. You define `__add__` to return a new `Matrix`. However, `sum([m1, m2, m3])` raises a `TypeError`. What is the most likely reason?

Which THREE of the following are potential pitfalls of the Singleton pattern in Python?

A developer is designing a `Shape` base class and wants subclasses to be forced to implement an `area()` method. Which two approaches are valid in Python for enforcing that subclasses provide `area()`? (Choose two.)

How do you implement the 'Strategy' pattern in Python?

When designing a class hierarchy, what is the best way to prevent a method from being overridden by subclasses?

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?

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?

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`?

How do you correctly call a method from a sibling class in a diamond inheritance structure using super()?

Which TWO of the following are correct regarding the 'with' statement in Python?

In the context of the Factory pattern, what does a concrete factory implement?

When implementing the Singleton pattern, what is the advantage of using a module-level instance over a class-based Singleton?

What is the purpose of the __repr__ method?

Why does the 'abc' module provide the 'ABCMeta' metaclass?

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?

Which THREE of the following represent common issues when using __slots__?

You are implementing the Observer pattern. Why should you avoid using a strong reference to the observers in the subject's list?

What is the primary difference between @classmethod and @staticmethod?

Which magic method enables index access (e.g., obj[i])?

Which TWO of the following are true about magic methods?

Which TWO of the following are valid ways to create a singleton in Python?

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?

What happens when you add two objects of a class that implements __add__?

If you define a class with a metaclass that has a custom __call__ method, when is that __call__ method executed?

Which method is used to customize the behavior of the 'in' operator?

Which magic method should you implement to make your objects support the 'with' statement context manager?

Which function is used to check if an object is an instance of a class?

In the context of the Factory pattern in Python, what is a typical benefit of using a registry-based approach instead of a large if-else block?

Why might you use the __init_subclass__ hook instead of a metaclass?