In this article, we will discuss about design patterns in brief and discuss one of the creational design pattern named as Factory Method Design Pattern. We will discuss when it is relevant to use Factory Design pattern and when it is not. Finally, we will implement a use case scenario for Factory Design Pattern in Python 3.
Design pattern, Factory Design Pattern in Python, Creational Design Pattern, Example of Factory Design pattern in Python
Design patterns define tried and tested solutions to various recurring problems in software development. Broadly, design patterns are divided into creational patterns, structural patterns, and behavioral patterns.
In a nutshell, Design pattern provides two major benefits: a) They provide a mechanism to solve issues related to software development using a proven solution, b) the solution facilitates the development of highly cohesive modules with minimal coupling. Here are the list of other benefits of design patterns in general:
- Design pattern give the developer a selection of tried and tested solution to work with.
- They are independent of any programming language. Hence, it can be applied to any programming languages that support OOP paradigm.
- They have a proven track record as they are already widely used and thus reduce the technical risk of the project.
- They are flexible and can be used practically in any type of application domain.
- They help in communication as they are well documented and can be researched if that is not the case.
The Factory Method Design Pattern is a type of creational design pattern. And in this article, we will discuss in detail about it.
Consider a use case from a software that I have been developing for Internet-Delivered Psychological System (IDPT). Generally, consider it as a typical CMS system where, an object
text. Check the UML diagram given below:
We start by creating
abstract classto represent generic
task. Look at the implementation code given below.
# Import Abstract Base Class import abc class Task(metaclass=abc.ABCMeta): @abc.abstractmethod def total_duration(self): pass @abc.abstractmethod def required_duration(self): pass @abc.abstractmethod def display(self): pass
This is the
base classfor all our tasks. When we say
abstract class, we define the placeholder attributes and properties that should be implemented by child classes.
Now, let us go ahead and install some of the dependencies that we shall be using during the class implementation. I am going to use
readtime. Let us install them right away.
!pip install faker from faker import Faker fake = Faker()
!pip install lorem-text !pip install readtime
Now, let us go ahead and create several
concrete, more specific
taskclasses. Note, as shown in the UML diagram above,
VIDEOare the types of
import random import readtime class Text(Task): def __init__(self, id, htmlText): self.id = id self.htmlText = htmlText def total_duration(self): return readtime.of_text(self.htmlText) def required_duration(self): return self.total_duration() def display(self): return self.htmlText class Audio(Task): def __init__(self, id, link): self.id = id self.link = link def total_duration(self): return '2 min' def required_duration(self): return '2 min' def display(self): return self.link class Video(Task): def __init__(self, id, link): self.id = id self.link = link def total_duration(self): return '4 min' def required_duration(self): return '4 min' def display(self): return self.link
So far, we have created an abstract class
Taskand extended it to three other classes namely
Video. In order to create the different sub-classes, client will have to know the names and details of the shapes and separately perform the creation. This is where the Factory method comes into play.
The factory method design pattern will help us to abstract the available shapes from the client. It allows us to centralize and encapsulate the object creation.
Now, let us create a factory named,
TaskFactorythat will help us create the specific
Taskclasses based on the client input.
from lorem_text import lorem class TaskFactory: def create_task(self, name): if name == 'text': id = random.randint(1, 1000) htmlText = lorem.paragraph() return Text(id, htmlText) elif name == 'audio': id = random.randint(1, 1000) link = fake.hostname()+'/audio/listen.mp3' return Audio(id, link) elif name == 'video': id = random.randint(1, 1000) link = fake.hostname()+'/video/video.mp4' return Video(id, link)
This is the interface for creation. We do not call the abstract class, instead we call the factory and ask it to create a
Taskfor us. For example, if we want to create a
Videotask, then we can initiate the Factory as given below:
factory = TaskFactory() xx = factory.create_task('video') xx.display()
The output of the above code is given below. Please note, since, I have used the
fakerto generate some data, the output you might get can be different from the one I have below:
- The code becomes loosely coupled. That is to say, one component of the codebase are unaware of the other component.
- The code is easy to understand and test.
- Extendability is easier as we can add more functionality to specific components without affecting or breaking the entire program.
- Factory method supports SOLID principle where each classes and objects handles one specific functionality.
- Factory method entails to create more classes which eventually leads to less readability.
In conclusion, the Factory Method Design Pattern allows us to create objects without specifying the exact class required to create the particular object. This allows us to decouple our code and enhances its reusability.
It is important to note that, just like any other design pattern, it is only suitable for specific situations and not every development scenario. An assessment of the situation at hand is crucial before deciding to implement the Factory Method Design Pattern to reap the benefits of the pattern.