Advanced Object Oriented Programming

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

What happens if you use a decorator on a class that returns a modified version of the class?

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?

In the context of the Descriptor Protocol, what is the primary difference between a data descriptor and a non-data descriptor?

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

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

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

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

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

Which THREE of the following statements are correct about Python metaclasses?

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?

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?

Which THREE of the following are true about the Python descriptor protocol?

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?

You are implementing a Singleton pattern using the __new__ method. Why is it considered best practice to also define a __call__ method in the metaclass or use a decorator instead of just overriding __new__ in the base class?

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?

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

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

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?

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?

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?

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?

Consider a class that uses a metaclass to automatically register subclasses in a dictionary. If you want to prevent the base class itself from being registered, how should the metaclass be implemented?

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