PCPP2 Design Patterns — Timed 15 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

Question 11

In the Decorator pattern, why is it preferred to use the functools.wraps decorator when creating a function decorator?

Accepted Answer

It preserves the metadata of the original function. functools.wraps preserves the metadata (like __name__ and __doc__) of the original function, which is critical for debugging and reflection.

Answer

It automatically implements the Singleton pattern

Answer

It prevents the decorator from being applied multiple times

Answer

It ensures the function runs faster

Question 12

You are implementing a Prototype pattern. What is the difference between shallow copy and deep copy in the context of cloning objects?

Accepted Answer

Shallow copy duplicates the reference, deep copy duplicates the object contents. A shallow copy creates a new object but references the same nested objects, while a deep copy recursively clones all nested objects.

Answer

Both copies result in the same memory address

Answer

Shallow copy clones nested objects, deep copy does not

Answer

Deep copy is always faster than shallow copy

Question 13

You are implementing the Flyweight pattern to optimize memory usage for a text processor. What is the distinction between 'intrinsic' and 'extrinsic' state?

Accepted Answer

Intrinsic state is shared/immutable, extrinsic is context-dependent. Intrinsic state is shared and immutable (stored in the Flyweight), while extrinsic state is unique to the context and passed into the Flyweight's methods.

Answer

Both are shared, but intrinsic is stored in a database

Answer

Neither state can be changed once the Flyweight is instantiated

Answer

Intrinsic state is the unique data, extrinsic is the shared data

Question 14

You are using the Composite pattern to represent a tree structure of UI elements. What is the most critical challenge when implementing a 'get_parent' method in this pattern?

Accepted Answer

It requires the base Component class to store a reference to the parent. The Composite pattern typically flows downward; maintaining an upward reference (parent pointer) creates bidirectional dependencies that make removing or moving nodes complex.

Answer

It requires the Leaf objects to also implement the same parent reference logic

Answer

It makes the children too independent

Answer

Python's memory management cannot handle circular references

Question 15

Which Python design principle is most strongly supported by the Adapter pattern?

Accepted Answer

Open/Closed Principle. The Adapter pattern allows incompatible interfaces to work together, promoting the Open/Closed Principle by allowing new adapters without changing existing code.

Answer

Single Responsibility Principle

Answer

Dependency Inversion Principle

Answer

Liskov Substitution Principle