Design patterns are like proven solutions to common problems that software developers face. They give guidelines on structuring code and solving design issues flexibly and efficiently. Design patterns make code easier to read, reuse, and scale, making software development more efficient and reliable.

They are helpful to developers who focus on essential elements of the design instead of getting caught up in small details. The design patterns are a set of best practices developers can use to improve their software.

They promote good coding habits and make it easier to build software that can be easily modified and expanded upon in the future.

Types of Design Patterns

1. Creational Patterns: These patterns focus on how objects are created. They provide flexible and controlled ways to create objects. Examples consist of Factory, Singleton, and Prototype patterns.

Singleton Pattern Example

The Singleton pattern ensures a single instance of a class is globally accessible.

Source Code:

class Singleton:

    _instance = None

    def __new__(cls):

        if not cls._instance:

            cls._instance = super().__new__(cls)

        return cls._instance

# Usage

instance1 = Singleton()

instance2 = Singleton()

print(instance1 is instance2)

Output :

Factory Pattern Example :

from abc import ABC, abstractmethod

class Animal(ABC):

    @abstractmethod

    def speak(self):

        pass

class Dog(Animal):

    def speak(self):

        return "Woof!"

class Cat(Animal):

    def speak(self):

        return "Meow!"

class AnimalFactory:

    @staticmethod

    def create_animal(animal_type):

        if animal_type == 'dog':

            return Dog()

        elif animal_type == 'cat':

            return Cat()

        else:

            raise ValueError(f"Invalid animal type: {animal_type}")

# Usage

factory = AnimalFactory()

dog = factory.create_animal('dog')

print(dog.speak())

cat = factory.create_animal('cat')

print(cat.speak())

Output :

Prototype Pattern :

The Prototype pattern allows for creating new objects by existing objects, promoting reusability and reducing the need for complex initialization processes or subclassing.

Source Code :

import copy

class Prototype:

    def clone(self):

        pass

class Rectangle(Prototype):

    def __init__(self, width, height):

        self.width = width

        self.height = height

    def clone(self):

        return copy.deepcopy(self)

    def __str__(self):

        return f"Rectangle: width={self.width}, height={self.height}"

# Usage

rectangle = Rectangle(10, 5)

print(rectangle)

clone_rectangle = rectangle.clone()

print(clone_rectangle)

clone_rectangle.width = 7

print(clone_rectangle)

Output :

2. Structural Patterns: These patterns organize and compose classes and objects. They enhance the functionality and relationships between objects. Examples consist of Adapters, decorators, and Composite patterns

Adapter Pattern: The Adapter pattern converts the interface of one class into another interface that clients expect, enabling objects with incompatible interfaces to work together.

Source Code :

# Adaptee class

class LegacyCalculator:

    def add_numbers(self, x, y):

        return x + y

# Target interface

class Calculator:

    def add(self, x, y):

        pass

# Adapter class

class CalculatorAdapter(Calculator):

    def __init__(self, legacy_calculator):

        self.legacy_calculator = legacy_calculator

    def add(self, x, y):

        return self.legacy_calculator.add_numbers(x, y)

# Usage

legacy_calculator = LegacyCalculator()

adapter = CalculatorAdapter(legacy_calculator)

result = adapter.add(5, 3)

print(result)

Output:

Composite Pattern :

The Composite pattern enables you to create hierarchical structures of objects where individual and group objects can be treated uniformly.

Source Code :

# Component interface

class Component:

    def operation(self):

        pass

# Leaf class

class Leaf(Component):

    def operation(self):

        print("Leaf operation")

# Composite class

class Composite(Component):

    def __init__(self):

        self.children = []

    def add(self, component):

        self.children.append(component)

    def remove(self, component):

        self.children.remove(component)

    def operation(self):

        print("Composite operation")

        for child in self.children:

            child.operation()

# Usage

leaf1 = Leaf()

leaf2 = Leaf()

composite = Composite()

composite.add(leaf1)

composite.add(leaf2)

composite.operation()

Output:

3. Behavioral Patterns: These patterns focus on how objects communicate and interact with each other. They define patterns of communication and collaboration to ensure practical object cooperation. Examples includes Observer, Strategy, and Command patterns.

Command Pattern:

The Command sample encapsulates requests as objects, decoupling senders from receivers and allowing for flexible request handling and undoable operations.

Source Code:

# Receiver class

class Light:

    def turn_on(self):

        print("Light is on.")

    def turn_off(self):

        print("Light is off.")

# Command interface

class Command:

    def execute(self):

        pass

# Concrete command classes

class TurnOnCommand(Command):

    def __init__(self, light):

        self.light = light

    def execute(self):

        self.light.turn_on()

class TurnOffCommand(Command):

    def __init__(self, light):

        self.light = light

    def execute(self):

        self.light.turn_off()

# Usage

light = Light()

turn_on_command = TurnOnCommand(light)

turn_off_command = TurnOffCommand(light)

# Execute the commands

turn_on_command.execute()

turn_off_command.execute()

Output :

Advantages of Design Patterns

1. Problem-Solving: Design patterns offer proven solutions to recurring problems. By following established patterns, we can efficiently address common challenges, saving time and effort in finding solutions from scratch.

2. Best Practices: Design patterns encapsulate best practices and guidelines from experienced developers. The industry knowledge and collective wisdom ensure that we adopt attempted-and-examined approaches that lead to robust, maintainable, and efficient solutions.

3. Code Readability and Maintainability: Design patterns promote code organization and structure. They improve code readability, making it easier for developers to understand and maintain.

4. Collaboration and Communication: Design patterns provide a common language and vocabulary for developers. They serve as a communication tool, enabling teams to discuss and share design decisions effectively. This shared understanding fosters collaboration, teamwork, and a smoother development process.

5. Flexibility and Adaptability: Design patterns enhance the adaptability and flexibility of software systems. By designing applications with patterns, we can more easily accommodate changes, new features, and evolving requirements. Patterns facilitate modularity, making modifying or replacing specific components easier without affecting the entire system.

6. Maintainable Code: Design patterns improve code maintainability by separating concerns, encapsulating functionality, and promoting modularity. They make it easier to manage changes and keep the codebase organized.

7. Scalability and Performance: Certain design patterns improve scalability and performance. For example, the sample reduces memory usage by sharing common data, while the pattern controls resource access, enhancing performance.

← Prev Next →

Design Pattern Overview

Types of Design Patterns

Singleton Pattern Example

Factory Pattern Example :

Prototype Pattern :

Composite Pattern :

Command Pattern:

Advantages of Design Patterns