PCPP2 Design Patterns — 10 Questions

Question 1

When using the Template Method pattern, which Python feature prevents subclasses from overriding specific steps of the algorithm?

Accepted Answer

Use the @final decorator from the typing module. While Python doesn't have strict 'final' methods, a common convention is to name a method with a double underscore prefix (mangled) or document it as private to discourage overriding.

Answer

Use the @abstractmethod decorator

Answer

Use the @staticmethod decorator

Answer

Use the private keyword

Question 2

In a Factory Method pattern, you have a base creator class with an abstract method create_product(). How should a concrete creator implementation be structured to adhere to Python's abc module standards?

Accepted Answer

Provide a concrete implementation of the method and inherit from the ABC base class. Subclasses must implement the abstract method defined by the base class using the @abstractmethod decorator.

Answer

Raise NotImplementedError in the base class instead of using decorators

Answer

Define the method as a static method using @staticmethod

Answer

Use the @abstractmethod decorator on the concrete implementation

Question 3

You are implementing a Singleton pattern in Python using a metaclass. Which mechanism ensures that the __call__ method of the metaclass is only executed once for a specific class?

Accepted Answer

Implementing a dictionary within the metaclass to cache and return existing instances. The metaclass __call__ method controls instance creation. By using a dictionary within the metaclass to store existing instances, you ensure that subsequent calls return the cached instance.

Answer

Setting the class variable __instance__ to None in the global scope

Answer

Overriding the __init__ method of the object class

Answer

Using the __new__ method of the target class instead of the metaclass

Question 4

In the Observer pattern, what is the best way to prevent memory leaks when the Subject maintains a list of Observers?

Accepted Answer

Use the weakref module to store references to the Observers. If the Subject maintains strong references to Observers, they cannot be garbage collected. Using weak references allows them to be collected when no longer used elsewhere.

Answer

Use a global list of observers to manage them centrally

Answer

Set the Observer list to None after every notification cycle

Answer

Explicitly call the detach method for every Observer

Question 5

You are implementing the Command pattern. How can you best support the 'Undo' operation for a command that changes a document's state?

Accepted Answer

Store the delta or previous state information within the concrete command instance. The Command object must store the previous state or the inverse operation before performing the change, allowing it to revert the state later.

Answer

Use the Python 'copy' module to clone the document before every command

Answer

Store the entire document object in the command history

Answer

Re-execute the entire command history up to the point of the undo

Question 6

You are implementing a Proxy pattern to provide lazy initialization for a resource-heavy object. Which technique is most effective for checking if the real object exists without triggering its constructor prematurely?

Accepted Answer

Check if the object attribute is None before calling the constructor. The Proxy should hold a reference to the real object and only instantiate it when a method is called that requires the real object's functionality.

Answer

Use the @property decorator to trigger instantiation immediately upon object creation

Answer

Overload the __del__ method to release the resource

Answer

Use a try-except block around the Proxy's constructor

Question 7

You are applying the Facade pattern to simplify a complex subsystem consisting of three interacting legacy modules. What is the primary architectural requirement for the Facade class to be effective?

Accepted Answer

The Facade should provide a simplified interface that delegates requests to appropriate subsystem objects. The Facade must act as a single entry point, encapsulating the complexity of the internal modules so the client doesn't need to know about them.

Answer

The Facade must inherit from every class in the subsystem

Answer

The Facade must implement the Singleton pattern to ensure only one interface exists

Answer

The Facade should expose all methods of the subsystem classes for flexibility

Question 8

You are designing a State pattern. Which component is responsible for changing the state of the context object?

Accepted Answer

The concrete state objects. Either the Context or the State objects themselves can transition the state, but encapsulating the transition logic inside the concrete state objects is typical for complex state flows.

Answer

The abstract state base class

Answer

A separate controller object

Answer

The client code

Question 9

In the Chain of Responsibility pattern, how does a handler decide whether to pass a request to the next handler?

Accepted Answer

By calling the next handler's handle method only if it cannot fulfill the request. Each handler evaluates if it can process the request; if not, it calls the successor in the chain.

Answer

By querying the client for the next handler

Answer

By using an exception to jump to the next handler

Answer

By returning True from a base handler method

Question 10

When implementing the Strategy pattern, what is the best way to inject the strategy into the context object?

Accepted Answer

Pass the strategy instance to the context's constructor. Dependency injection, usually via the constructor, allows the context to remain agnostic of the specific strategy implementation.

Answer

Use a global variable for the strategy

Answer

Import the strategy module inside the context's run method

Answer

Hardcode the strategy class inside the context's __init__ method