Prototype Method Design Pattern in Python
Last Updated :
22 Jul, 2024
The Prototype Method Design Pattern in Python enables the creation of new objects by cloning existing ones, promoting efficient object creation and reducing overhead. This pattern is particularly useful when the cost of creating a new object is high and when an object's initial state or configuration is complex.
- By utilizing cloning, developers can streamline object creation, ensuring that new instances are created with the same properties and behaviors as the prototype, while also allowing for easy customization and modification.
- This article explores the implementation and benefits of the Prototype Method Design Pattern in Python.
Suppose a user creates a document with a specific layout, fonts, and styling, and wishes to create similar documents with slight modifications.
Instead of starting from scratch each time, the user can use the Prototype pattern. The original document becomes the prototype, and new documents are created by cloning this prototype. This approach ensures that the new documents inherit the structure and styling of the original document while allowing for customization.
Important Topics for Prototype Method Design Pattern in Python
Components of Prototype Design Pattern
The Prototype Design Pattern's components include the prototype interface or abstract class, concrete prototypes and the client code, and the clone method specifying cloning behavior. These components work together to enable the creation of new objects by copying existing ones.
.png)
1. Prototype Interface or Abstract Class
The Prototype Interface or Abstract Class declares the method(s) for cloning an object. It defines the common interface that concrete prototypes must implement, ensuring that all prototypes can be cloned in a consistent manner.
- The main role is to provide a blueprint for creating new objects by specifying the cloning contract.
- It declares the
clone method, which concrete prototypes implement to produce copies of themselves.
2. Concrete Prototype
The Concrete Prototype is a class that implements the prototype interface or extends the abstract class. It's the class representing a specific type of object that you want to clone.
- It defines the details of how the cloning process should be carried out for instances of that class.
- Implements the
clone method declared in the prototype interface, providing the cloning logic specific to the class.
3. Client
The Client is the code or module that requests the creation of new objects by interacting with the prototype. It initiates the cloning process without being aware of the concrete classes involved.
4. Clone Method
The Clone Method is declared in the prototype interface or abstract class. It specifies how an object should be copied or cloned. Concrete prototypes implement this method to define their unique cloning behavior. It Describes how the object's internal state should be duplicated to create a new, independent instance.
Prototype Design Pattern example in Python
In a video game, different types of enemies need to be created with similar initial attributes but slight variations. Creating each enemy from scratch every time it is needed can be inefficient, especially if the enemies share many common attributes. The challenge is to efficiently create these enemies while allowing for easy customization.
How Prototype Design Pattern helps to solve this problem?
Using the Prototype Design Pattern, we can create a prototype of each type of enemy and then clone these prototypes to create new enemies. This approach reduces the overhead of creating each enemy from scratch and ensures that new enemies start with the same attributes as the prototype. Customization can be applied to each cloned enemy as needed.
Class Diagram of Prototype Method Design Pattern in Python1. Prototype Interface
Python
from abc import ABC, abstractmethod
import copy
class Prototype(ABC):
@abstractmethod
def clone(self):
pass
2. Concrete Prototype (Enemy Prototype)
Python
class EnemyPrototype(Prototype):
def __init__(self, name, health, attack_power):
self.name = name
self.health = health
self.attack_power = attack_power
def clone(self):
return copy.deepcopy(self)
def __str__(self):
return f"Enemy(name={self.name}, health={self.health}, attack_power={self.attack_power})"
3. Client
Python
def client_code(prototype: Prototype):
prototype_clone = prototype.clone()
print("Cloned enemy:", prototype_clone)
# Customizing the cloned enemy
prototype_clone.health += 10
prototype_clone.attack_power += 5
print("Customized cloned enemy:", prototype_clone)
4. Complete code for the above example
Python
from abc import ABC, abstractmethod
import copy
class Prototype(ABC):
@abstractmethod
def clone(self):
pass
class EnemyPrototype(Prototype):
def __init__(self, name, health, attack_power):
self.name = name
self.health = health
self.attack_power = attack_power
def clone(self):
return copy.deepcopy(self)
def __str__(self):
return f"Enemy(name={self.name}, health={self.health}, attack_power={self.attack_power})"
def client_code(prototype: Prototype):
prototype_clone = prototype.clone()
print("Cloned enemy:", prototype_clone)
# Customizing the cloned enemy
prototype_clone.health += 10
prototype_clone.attack_power += 5
print("Customized cloned enemy:", prototype_clone)
if __name__ == "__main__":
# Creating a prototype for a basic enemy
basic_enemy_prototype = EnemyPrototype("Goblin", 100, 15)
print("Original enemy:", basic_enemy_prototype)
# Using the prototype to create and customize new enemies
client_code(basic_enemy_prototype)
OutputOriginal enemy: Enemy(name=Goblin, health=100, attack_power=15)
Cloned enemy: Enemy(name=Goblin, health=100, attack_power=15)
Customized cloned enemy: Enemy(name=Goblin, health=110, attack_power=20)
Explanation
- Prototype Interface: Defines the
clone method that must be implemented by any class that wants to allow cloning. - Concrete Prototype (EnemyPrototype): Implements the
clone method using copy.deepcopy to create a deep copy of the object. - Client: Uses the prototype to create a clone and then customizes the cloned object as needed.
In this example, the EnemyPrototype class is used to create prototypes for different types of enemies. The client_code function clones the prototype and customizes the cloned enemy. This pattern allows efficient creation of new enemies while ensuring they start with the same state as the prototype and can be easily customized afterward.
When to use the Prototype Design Pattern
- Creating Objects is Costly:
- Use the Prototype pattern when creating objects is more expensive or complex than copying existing ones.
- If object creation involves significant resources, such as database or network calls, and you have a similar object available, cloning can be more efficient.
- Variations of Objects:
- Use the Prototype pattern when your system needs to support a variety of objects with slight variations.
- Instead of creating multiple classes for each variation, you can create prototypes and clone them with modifications.
- Dynamic Configuration:
- Use the Prototype pattern when your system requires dynamic configuration and you want to create objects with configurations at runtime.
- You can prototype a base configuration and clone it, adjusting the properties as needed.
- Reducing Initialization Overhead:
- Use the Prototype pattern when you want to reduce the overhead of initializing an object.
- Creating a clone can be faster than creating an object from scratch, especially when the initialization process is resource-intensive.
When not to use the Prototype Design Pattern
- Unique Object Instances:
- Avoid using the Prototype pattern when your application predominantly deals with unique object instances, and the overhead of implementing the pattern outweighs its benefits.
- Simple Object Creation:
- If object creation is simple and does not involve significant resource consumption, and there are no variations of objects, using the Prototype pattern might be unnecessary complexity.
- Immutable Objects:
- If your objects are immutable (unchangeable) and do not need variations, the benefits of cloning may not be significant.
- Immutable objects are often safely shared without the need for cloning.
- Clear Object Creation Process:
- If your system has a clear and straightforward object creation process that is easy to understand and manage, introducing the Prototype pattern may add unnecessary complexity.
- Limited Object Variations:
- If there are only a few variations of objects, and creating subclasses or instances with specific configurations is manageable, the Prototype pattern might be overkill.