Skip to main content

Python Design Patterns

Introduction​

Design patterns are reusable solutions to common problems that arise during software design. They represent best practices evolved over time by experienced software developers. Rather than solving specific problems, design patterns provide templates for addressing categories of challenges, making code more maintainable, flexible, and easier to understand.

In Python, design patterns take on a slightly different character than in strictly object-oriented languages like Java or C++. Python's dynamic nature, duck typing, and first-class functions allow for more concise and sometimes more elegant implementations of traditional design patterns.

This guide will introduce you to key design patterns and their Python implementations, helping you recognize when and how to apply them in your own projects.

Why Learn Design Patterns?​

Before diving into specific patterns, let's understand why design patterns are valuable:

  1. Common vocabulary - They provide a standard terminology for specific approaches
  2. Proven solutions - They represent time-tested solutions to recurring problems
  3. Code reusability - They promote the "don't reinvent the wheel" principle
  4. Better code organization - They help structure code in a more manageable way
  5. Scalability - They make code easier to extend without major modifications

Types of Design Patterns​

Design patterns fall into three main categories:

  1. Creational Patterns - Concerned with object creation mechanisms
  2. Structural Patterns - Deal with relationships between objects
  3. Behavioral Patterns - Focus on communication between objects

Let's explore representative patterns from each category.

Creational Patterns​

Singleton Pattern​

The Singleton pattern ensures a class has only one instance and provides a global point of access to it.

python
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
            cls._instance.value = 0  # Initialize instance state
        return cls._instance

# Usage example
s1 = Singleton()
s1.value = 42
s2 = Singleton()

print(s1.value)  # Output: 42
print(s2.value)  # Output: 42
print(s1 is s2)  # Output: True

In this example, no matter how many times we instantiate Singleton, we always get back the same instance. This pattern is useful for managing resources that should be shared throughout the application, like configuration managers or connection pools.

Factory Pattern​

The Factory pattern provides an interface for creating objects without specifying their concrete classes.

python
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")

# Usage example
factory = AnimalFactory()
dog = factory.create_animal("dog")
cat = factory.create_animal("cat")

print(dog.speak())  # Output: Woof!
print(cat.speak())  # Output: Meow!

The Factory pattern helps decouple client code from the specific classes being instantiated. This makes it easier to add new types without changing existing code.

Structural Patterns​

Adapter Pattern​

The Adapter pattern allows objects with incompatible interfaces to collaborate.

python
# Existing class with incompatible interface
class OldSystem:
    def old_operation(self):
        return "Old system operation"

# Target interface our client expects
class NewInterface:
    def new_operation(self):
        pass

# Adapter makes OldSystem compatible with NewInterface
class Adapter(NewInterface):
    def __init__(self, old_system):
        self.old_system = old_system
        
    def new_operation(self):
        # Call the old system but return in the format expected by clients
        result = self.old_system.old_operation()
        return f"Adapted: {result}"

# Client code
def client_code(target):
    print(target.new_operation())

# Usage
old_system = OldSystem()
adapter = Adapter(old_system)
client_code(adapter)  # Output: Adapted: Old system operation

The Adapter pattern is particularly useful when integrating with legacy code or third-party libraries that have interfaces different from what your application requires.

Decorator Pattern​

The Decorator pattern adds new behaviors to objects dynamically by placing them inside wrapper objects.

python
from functools import wraps

def bold(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

@bold
@italic
def generate_text(text):
    return text

# Usage
print(generate_text("Hello, world!"))  # Output: <b><i>Hello, world!</i></b>

Python's decorators are an elegant implementation of the Decorator pattern. They allow you to modify the behavior of a function or method without changing its core implementation.

Behavioral Patterns​

Observer Pattern​

The Observer pattern defines a subscription mechanism to notify multiple objects about events that happen to the observed object.

python
class Subject:
    def __init__(self):
        self._observers = []
        self._state = None
        
    def attach(self, observer):
        if observer not in self._observers:
            self._observers.append(observer)
            
    def detach(self, observer):
        try:
            self._observers.remove(observer)
        except ValueError:
            pass
            
    def notify(self):
        for observer in self._observers:
            observer.update(self)
            
    @property
    def state(self):
        return self._state
        
    @state.setter
    def state(self, value):
        self._state = value
        self.notify()

class Observer:
    def update(self, subject):
        pass

class ConcreteObserverA(Observer):
    def update(self, subject):
        print(f"ConcreteObserverA: Reacted to the event. New state: {subject.state}")

class ConcreteObserverB(Observer):
    def update(self, subject):
        print(f"ConcreteObserverB: Reacted to the event. New state: {subject.state}")

# Usage
subject = Subject()

observer_a = ConcreteObserverA()
subject.attach(observer_a)

observer_b = ConcreteObserverB()
subject.attach(observer_b)

subject.state = 123  
# Output:
# ConcreteObserverA: Reacted to the event. New state: 123
# ConcreteObserverB: Reacted to the event. New state: 123

subject.detach(observer_a)
subject.state = 456
# Output:
# ConcreteObserverB: Reacted to the event. New state: 456

The Observer pattern is useful when changes to one object require changing others, but you don't know how many objects need to change. It's commonly used in implementing event handling systems.

Strategy Pattern​

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable.

python
from abc import ABC, abstractmethod

# Strategy interface
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

# Concrete strategies
class QuickSort(SortStrategy):
    def sort(self, data):
        print("Sorting using QuickSort")
        # Implementation would be here
        return sorted(data)  # Using Python's sort for simplicity

class MergeSort(SortStrategy):
    def sort(self, data):
        print("Sorting using MergeSort")
        # Implementation would be here
        return sorted(data)  # Using Python's sort for simplicity

class BubbleSort(SortStrategy):
    def sort(self, data):
        print("Sorting using BubbleSort")
        # Implementation would be here
        return sorted(data)  # Using Python's sort for simplicity

# Context
class SortContext:
    def __init__(self, strategy=None):
        self._strategy = strategy
        
    @property
    def strategy(self):
        return self._strategy
        
    @strategy.setter
    def strategy(self, strategy):
        self._strategy = strategy
        
    def sort(self, data):
        if self._strategy is None:
            raise ValueError("Strategy is not set")
        return self._strategy.sort(data)

# Usage
context = SortContext()

# Using QuickSort
context.strategy = QuickSort()
result = context.sort([3, 1, 4, 1, 5, 9, 2, 6])
print(result)
# Output:
# Sorting using QuickSort
# [1, 1, 2, 3, 4, 5, 6, 9]

# Switching to MergeSort
context.strategy = MergeSort()
result = context.sort([3, 1, 4, 1, 5, 9, 2, 6])
print(result)
# Output:
# Sorting using MergeSort
# [1, 1, 2, 3, 4, 5, 6, 9]

The Strategy pattern is particularly useful when you want to:

  • Define a family of algorithms
  • Make algorithms interchangeable within that family
  • Isolate the algorithm from the client code that uses it

Real-World Application Example​

Let's integrate multiple design patterns in a more realistic scenario: a notification system for an e-commerce application.

python
from abc import ABC, abstractmethod
from datetime import datetime
import json

# Observer Pattern - Define notification system
class OrderSubject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        if observer not in self._observers:
            self._observers.append(observer)
    
    def detach(self, observer):
        try:
            self._observers.remove(observer)
        except ValueError:
            pass
    
    def notify(self, order):
        for observer in self._observers:
            observer.update(order)

# Strategy Pattern - Different notification methods
class NotificationStrategy(ABC):
    @abstractmethod
    def send(self, message, recipient):
        pass

class EmailNotification(NotificationStrategy):
    def send(self, message, recipient):
        print(f"Sending EMAIL to {recipient}: {message}")

class SMSNotification(NotificationStrategy):
    def send(self, message, recipient):
        print(f"Sending SMS to {recipient}: {message}")

class PushNotification(NotificationStrategy):
    def send(self, message, recipient):
        print(f"Sending PUSH notification to {recipient}: {message}")

# Factory Pattern - Create notification services
class NotificationFactory:
    @staticmethod
    def create_notifier(method):
        if method == "email":
            return EmailNotification()
        elif method == "sms":
            return SMSNotification()
        elif method == "push":
            return PushNotification()
        else:
            raise ValueError(f"Unknown notification method: {method}")

# Concrete observers for different notifications
class CustomerNotifier:
    def __init__(self, notification_strategy):
        self.notification_strategy = notification_strategy
    
    def update(self, order):
        message = f"Your order #{order.id} has been {order.status}"
        self.notification_strategy.send(message, order.customer_email)

class AdminNotifier:
    def __init__(self, notification_strategy):
        self.notification_strategy = notification_strategy
    
    def update(self, order):
        message = f"Order #{order.id} has been updated to: {order.status}"
        self.notification_strategy.send(message, "admin@example.com")

# Order model
class Order:
    def __init__(self, id, customer_email, items):
        self.id = id
        self.customer_email = customer_email
        self.items = items
        self.status = "pending"
        self.timestamp = datetime.now()
    
    def to_json(self):
        return json.dumps({
            "id": self.id,
            "customer": self.customer_email,
            "items": self.items,
            "status": self.status,
            "timestamp": self.timestamp.isoformat()
        })

# Singleton Pattern - Order Manager
class OrderManager:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(OrderManager, cls).__new__(cls)
            cls._instance.orders = {}
            cls._instance.notification_system = OrderSubject()
        return cls._instance
    
    def create_order(self, customer_email, items):
        order_id = f"ORD-{len(self.orders) + 1000}"
        order = Order(order_id, customer_email, items)
        self.orders[order_id] = order
        return order
    
    def update_order_status(self, order_id, new_status):
        if order_id not in self.orders:
            raise ValueError(f"Order {order_id} not found")
            
        order = self.orders[order_id]
        order.status = new_status
        
        # Notify all observers
        self.notification_system.notify(order)
        return order

# Usage example
def main():
    # Create notifiers with different strategies
    email_notifier = CustomerNotifier(
        NotificationFactory.create_notifier("email")
    )
    sms_notifier = CustomerNotifier(
        NotificationFactory.create_notifier("sms")
    )
    admin_notifier = AdminNotifier(
        NotificationFactory.create_notifier("push")
    )
    
    # Get the order manager singleton
    order_manager = OrderManager()
    
    # Register observers
    order_manager.notification_system.attach(email_notifier)
    order_manager.notification_system.attach(sms_notifier)
    order_manager.notification_system.attach(admin_notifier)
    
    # Create a new order
    order = order_manager.create_order("customer@example.com", ["laptop", "mouse"])
    print(f"Created order: {order.to_json()}")
    
    # Update order status - this will trigger notifications
    updated_order = order_manager.update_order_status(order.id, "shipped")
    print(f"Updated order: {updated_order.to_json()}")

if __name__ == "__main__":
    main()

Running this example would output:

Created order: {"id": "ORD-1000", "customer": "customer@example.com", "items": ["laptop", "mouse"], "status": "pending", "timestamp": "2023-10-25T14:30:45.123456"}
Sending EMAIL to customer@example.com: Your order #ORD-1000 has been shipped
Sending SMS to customer@example.com: Your order #ORD-1000 has been shipped
Sending PUSH notification to admin@example.com: Order #ORD-1000 has been updated to: shipped
Updated order: {"id": "ORD-1000", "customer": "customer@example.com", "items": ["laptop", "mouse"], "status": "shipped", "timestamp": "2023-10-25T14:30:45.123456"}

In this example, we've combined several design patterns:

  • Observer Pattern: The notification system observes order status changes
  • Strategy Pattern: Different notification methods (email, SMS, push)
  • Factory Pattern: Creates the appropriate notification service
  • Singleton Pattern: Ensures a single OrderManager instance

This demonstrates how multiple design patterns can work together to create a flexible, maintainable system.

Python-Specific Pattern Implementations​

Python's dynamic nature allows for some unique implementations of design patterns:

Decorator Pattern with Function Decorators​

Python's built-in decorator syntax provides an elegant way to implement the decorator pattern:

python
import time
from functools import wraps

def timing_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time:.4f} seconds to run")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(1)
    return "Function completed"

print(slow_function())
# Output:
# Function slow_function took 1.0012 seconds to run
# Function completed

Singleton using a Metaclass​

Python's metaclasses offer an alternative way to implement singletons:

python
class Singleton(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=Singleton):
    def __init__(self):
        print("Initializing database connection")
        # Initialization code here

# Usage
db1 = Database()  # Output: Initializing database connection
db2 = Database()  # No output - reusing the same instance
print(db1 is db2)  # Output: True

When to Use (and Not Use) Design Patterns​

Design patterns are powerful tools, but they're not always the right solution:

Good times to use design patterns:​

  • When you encounter a problem that matches a pattern's use case
  • When you need a flexible, maintainable solution that can evolve
  • When communicating with other developers who understand these patterns

When to be cautious:​

  • Don't use patterns just to use patterns ("pattern fever")
  • For simple problems, simple solutions are often better
  • Patterns add complexity, which isn't always warranted

Summary​

Design patterns are valuable tools in a Python developer's toolkit. They provide tested solutions to common programming problems and improve code quality by making it more maintainable and flexible.

Key takeaways:

  • Creational patterns like Singleton and Factory help with object creation
  • Structural patterns like Adapter and Decorator help organize relationships between objects
  • Behavioral patterns like Observer and Strategy help manage algorithms and responsibilities
  • Python's dynamic nature allows for unique, often more concise implementations of traditional design patterns

Remember that design patterns are guidelines, not strict rules. Adapt them to your specific needs and the Python way of doing things.

Further Resources​

To continue learning about design patterns in Python:

  1. Books:

    • "Design Patterns: Elements of Reusable Object-Oriented Software" by the Gang of Four
    • "Python in Practice" by Mark Summerfield
    • "Fluent Python" by Luciano Ramalho (covers Python-specific patterns)

  2. Online Resources:

Exercises​

  1. Implement a Logger class using the Singleton pattern.
  2. Create a Command pattern implementation to build a simple text editor with undo/redo functionality.
  3. Refactor an existing piece of code to use the Strategy pattern for different calculation methods.
  4. Build a file processing system using the Chain of Responsibility pattern.
  5. Implement a caching system using the Proxy pattern to avoid expensive operations.

By understanding and applying design patterns appropriately, you'll write more maintainable, flexible, and professional Python code.


If you spot any mistakes on this website, please let me know at feedback@compilenrun.com. I’d greatly appreciate your feedback! :)