Software development

Discovering the Power of Design Patterns in Python

Discovering the Power of Design Patterns in Python

As software developers, we constantly strive to create elegant, efficient, and maintainable code. One way to achieve this is by using design patterns, which are proven solutions to recurring problems in software design. In this article, we will explore the concept of design patterns and demonstrate their implementation in Python with practical examples.

Table of Contents

  1. Introduction to Design Patterns
  2. Creational Patterns
    1. Singleton
    2. Factory Method
  3. Structural Patterns
    1. Adapter
    2. Decorator
  4. Behavioral Patterns
    1. Observer
    2. Strategy
  5. Conclusion

Introduction to Design Patterns

Design patterns are reusable solutions to common problems that occur in software design. They provide a blueprint for solving specific challenges and promote code reusability, modularity, and extensibility. There are three main categories of design patterns: creational, structural, and behavioral.

Creational Patterns

Creational patterns focus on object creation mechanisms, enabling flexible object instantiation. Let’s explore two commonly used creational patterns.


The Singleton pattern restricts the instantiation of a class to a single object. This pattern ensures that only one instance of a class exists throughout the application. Here’s an example:

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # Output: True

In the above code, two instances of the Singleton class are created. However, both references singleton1 and singleton2 denote the same object, proving that only a single instance is instantiated.

Factory Method

The Factory Method pattern provides an interface for creating objects but allows subclasses to decide which class to instantiate. This promotes loose coupling and encapsulation. Here’s a basic example:

from abc import ABC, abstractmethod

class Product(ABC):
    def operation(self):

class ConcreteProductA(Product):
    def operation(self):
        return "Product A"

class ConcreteProductB(Product):
    def operation(self):
        return "Product B"

class Creator(ABC):
    def factory_method(self):

    def some_operation(self):
        product = self.factory_method()
        return f"Do something with {product.operation()}"

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

creator_A = ConcreteCreatorA()
creator_B = ConcreteCreatorB()

print(creator_A.some_operation())  # Output: Do something with Product A
print(creator_B.some_operation())  # Output: Do something with Product B

In this example, the Creator class defines the generic some_operation method, while its subclasses (ConcreteCreatorA and ConcreteCreatorB) are responsible for creating the appropriate product instance (ConcreteProductA and ConcreteProductB).

Structural Patterns

Structural patterns focus on class and object composition, providing flexible ways to assemble objects. Let’s explore two commonly used structural patterns.


The Adapter pattern enables the interaction between incompatible interfaces. It acts as a translator, allowing classes with incompatible interfaces to work together. Here’s an example:

class Target:
    def request(self):
        return "Target: The default target's behavior."

class Adaptee:
    def specific_request(self):
        return "Adaptee: The specific request."

class Adapter(Target):
    def __init__(self, adaptee: Adaptee):
        self.adaptee = adaptee

    def request(self):
        return f"Adapter: Translated request - {self.adaptee.specific_request()}"

adaptee = Adaptee()
adapter = Adapter(adaptee)

print(adapter.request())  # Output: Adapter: Translated request - Adaptee: The specific request.

In this example, the Target interface defines the expected behavior, while the Adaptee class has a different interface. The Adapter class bridges the gap between the two, translating the Adaptee’s specific request to fulfill the Target interface.


The Decorator pattern allows the addition of behavior to an object dynamically. It provides an alternative to subclassing for extending functionality. Here’s an example:

class Component:
    def operation(self):

class ConcreteComponent(Component):
    def operation(self):
        return "ConcreteComponent: Operation definition."

class Decorator(Component):
    def __init__(self, component: Component):
        self.component = component

    def operation(self):
        return self.component.operation()

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"ConcreteDecoratorA: Operation definition and {super().operation()}"

class ConcreteDecoratorB(Decorator):
    def operation(self):
        return f"ConcreteDecoratorB: Operation definition and {super().operation()}"

component = ConcreteComponent()
decorator_A = ConcreteDecoratorA(component)
decorator_B = ConcreteDecoratorB(decorator_A)

print(decorator_B.operation())  # Output: ConcreteDecoratorB: Operation definition and ConcreteDecoratorA: Operation definition and ConcreteComponent: Operation definition.

In this example, the Component class defines the basic behavior, while Decorator subclasses add additional functionality. Multiple decorators can be chained together to extend the behavior of the object.

Behavioral Patterns

Behavioral patterns focus on communication between objects, defining how they interact and distribute responsibilities. Let’s explore two commonly used behavioral patterns.


The Observer pattern defines a one-to-many dependency between objects, ensuring that when one object changes state, multiple dependent objects are notified and updated automatically. Here’s an example:

class Subject:
    def __init__(self):
        self._observers = []

    def notify(self):
        for observer in self._observers:

    def attach(self, observer):

    def detach(self, observer):

class ConcreteSubject(Subject):
    def some_business_logic(self):

class Observer:
    def update(self):

class ConcreteObserverA(Observer):
    def update(self):
        return "ConcreteObserverA: Reacted to the update."

class ConcreteObserverB(Observer):
    def update(self):
        return "ConcreteObserverB: Reacted to the update."

subject = ConcreteSubject()
observer_A = ConcreteObserverA()
observer_B = ConcreteObserverB()


# Output:
# ConcreteObserverA: Reacted to the update.
# ConcreteObserverB: Reacted to the update.


# Output:
# ConcreteObserverA: Reacted to the update.

In this example, the Subject maintains a list of observers and notifies them of any changes. The observers, such as ConcreteObserverA and ConcreteObserverB, can react to these updates accordingly.


The Strategy pattern allows selecting the algorithm or behavior at runtime. It encapsulates interchangeable algorithms and makes them interchangeable within a particular context. Here’s an example:

from abc import ABC, abstractmethod

class Strategy(ABC):
    def execute_algorithm(self):

class ConcreteStrategyA(Strategy):
    def execute_algorithm(self):
        return "ConcreteStrategyA: Execute Algorithm A"

class ConcreteStrategyB(Strategy):
    def execute_algorithm(self):
        return "ConcreteStrategyB: Execute Algorithm B"

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

    def execute_operation(self):
        return self._strategy.execute_algorithm()

context = Context(ConcreteStrategyA())
print(context.execute_operation())  # Output: ConcreteStrategyA: Execute Algorithm A

context = Context(ConcreteStrategyB())
print(context.execute_operation())  # Output: ConcreteStrategyB: Execute Algorithm B

In this example, the Context class is decoupled from the concrete strategies (ConcreteStrategyA and ConcreteStrategyB). The context can switch between strategies at runtime, depending on the desired behavior.


Design patterns are powerful tools in the software developer’s arsenal. By leveraging design patterns, we can enhance code quality, maintainability, and reusability. In this article, we explored the concept of design patterns and discussed practical examples of their implementation in Python. Armed with this knowledge, you can apply design patterns to your own projects and write more robust and scalable software.

Remember, understanding design patterns is just the beginning. It’s essential to analyze and identify the appropriate design pattern for each unique problem you encounter in your software development journey.

Happy coding!

comments powered by Disqus