Python Design Patterns

Design patterns are typical solutions to common problems in software design. They represent best practices that can be applied to solve recurring design issues in a flexible and reusable way. Python, being a versatile and powerful programming language, supports various design patterns that can be used to structure your code more effectively, making it easier to maintain and extend.

Design patterns are categorized into three major types:

1. Creational Patterns: Deal with object creation mechanisms, trying to create objects in a manner suitable to the situation.
2. Structural Patterns: Deal with object composition, creating relationships between objects to form larger structures.
3. Behavioral Patterns: Deal with object interaction and responsibility distribution.

1. Creational Design Patterns

1.1 Singleton Pattern

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

Use Case: A logger class, where having multiple instances would lead to multiple log files, which is undesirable.

Example:

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance


# Testing Singleton
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # Output: True

In this example, no matter how many times we create an instance of Singleton, the same object is returned.

1.2 Factory Pattern

The Factory Pattern is used to create objects without specifying the exact class of object that will be created.

Use Case: A vehicle factory that produces different types of vehicles like cars, bikes, etc., but we do not know the exact vehicle type until runtime.

Example:

class Car:
    def drive(self):
        return "Driving a car."

class Bike:
    def drive(self):
        return "Riding a bike."

class VehicleFactory:
    def get_vehicle(self, vehicle_type):
        if vehicle_type == "car":
            return Car()
        elif vehicle_type == "bike":
            return Bike()


# Testing Factory
factory = VehicleFactory()
vehicle = factory.get_vehicle("car")
print(vehicle.drive())  # Output: Driving a car.

The factory creates and returns the appropriate type of vehicle based on the provided input.

2. Structural Design Patterns

2.1 Adapter Pattern

The Adapter Pattern allows incompatible classes to work together by converting one interface to another that the client expects.

Use Case: Adapting legacy code or third-party library code to work within an application.

Example:

class OldSystem:
    def get_data(self):
        return "Old data"

class NewSystem:
    def fetch_data(self):
        return "New data"

class Adapter:
    def __init__(self, new_system):
        self.new_system = new_system
    
    def get_data(self):
        return self.new_system.fetch_data()


# Testing Adapter
old_system = OldSystem()
new_system = NewSystem()
adapter = Adapter(new_system)

print(old_system.get_data())  # Output: Old data
print(adapter.get_data())     # Output: New data

The adapter converts the fetch_data method to the get_data method to be compatible with the old system.

2.2 Decorator Pattern

The Decorator Pattern allows adding functionality to an object dynamically, without altering its structure.

Use Case: Adding extra features to a UI component or extending the functionality of a method or class.

Example:

class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 2

class SugarDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 1


# Testing Decorator
coffee = Coffee()
milk_coffee = MilkDecorator(coffee)
sugar_milk_coffee = SugarDecorator(milk_coffee)

print(coffee.cost())            # Output: 5
print(milk_coffee.cost())       # Output: 7
print(sugar_milk_coffee.cost())  # Output: 8

Here, the MilkDecorator and SugarDecorator add functionality to the Coffee class dynamically.

3. Behavioral Design Patterns

3.1 Observer Pattern

The Observer Pattern defines a dependency between objects so that when one object changes state, all its dependents are notified automatically.

Use Case: An event-driven system, where multiple components need to listen to changes in a subject.

Example:

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

    def add_observer(self, observer):
        self._observers.append(observer)

    def notify_observers(self, message):
        for observer in self._observers:
            observer.update(message)

class Observer:
    def update(self, message):
        print(f"Observer received message: {message}")


# Testing Observer
subject = Subject()
observer1 = Observer()
observer2 = Observer()

subject.add_observer(observer1)
subject.add_observer(observer2)

subject.notify_observers("Update available!")  # Both observers will receive the message

The Observer objects will be notified when the Subject state changes.

3.2 Strategy Pattern

The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows a client to choose the appropriate algorithm at runtime.

Use Case: A payment system that allows users to select different payment methods like credit card, PayPal, etc.

Example:

class PayPal:
    def pay(self, amount):
        return f"Paying {amount} using PayPal."

class CreditCard:
    def pay(self, amount):
        return f"Paying {amount} using Credit Card."

class PaymentContext:
    def __init__(self, strategy):
        self._strategy = strategy
    
    def execute_payment(self, amount):
        return self._strategy.pay(amount)


# Testing Strategy
paypal = PayPal()
credit_card = CreditCard()

payment = PaymentContext(paypal)
print(payment.execute_payment(100))  # Output: Paying 100 using PayPal.

payment = PaymentContext(credit_card)
print(payment.execute_payment(200))  # Output: Paying 200 using Credit Card.

Here, the PaymentContext allows the payment strategy (either PayPal or CreditCard) to be changed dynamically.

4. Conclusion

Design patterns provide robust and flexible solutions to common problems in software development. Understanding and using design patterns can make your code more modular, scalable, and easier to maintain.

Summary of Key Patterns:

• Creational Patterns (e.g., Singleton, Factory): Focus on object creation.
• Structural Patterns (e.g., Adapter, Decorator): Deal with the composition of objects.
• Behavioral Patterns (e.g., Observer, Strategy): Handle communication between objects and their interactions.

By using these design patterns, Python developers can enhance the readability, maintainability, and scalability of their code.