Design Patterns in Python

Factory, observer, strategy, decorator, and other design patterns.

Overview

Implement common design patterns in Python.

Factory Pattern

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

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

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        animals = {
            "dog": Dog,
            "cat": Cat
        }
        return animals.get(animal_type.lower())()

factory = AnimalFactory()
dog = factory.create_animal("dog")
print(dog.speak())  # Woof!

Observer Pattern

class EventDispatcher:
    def __init__(self):
        self._listeners = {}
    
    def add_listener(self, event_type, listener):
        if event_type not in self._listeners:
            self._listeners[event_type] = []
        self._listeners[event_type].append(listener)
    
    def dispatch(self, event_type, data):
        if event_type in self._listeners:
            for listener in self._listeners[event_type]:
                listener(data)

# Usage
dispatcher = EventDispatcher()

def on_user_created(user):
    print(f"Welcome, {user}!")

def send_email(user):
    print(f"Sending welcome email to {user}")

dispatcher.add_listener("user_created", on_user_created)
dispatcher.add_listener("user_created", send_email)

dispatcher.dispatch("user_created", "Alice")
# Welcome, Alice!
# Sending welcome email to Alice

Strategy Pattern

class SortStrategy:
    def sort(self, data):
        raise NotImplementedError

class BubbleSort(SortStrategy):
    def sort(self, data):
        arr = data.copy()
        n = len(arr)
        for i in range(n):
            for j in range(0, n-i-1):
                if arr[j] > arr[j+1]:
                    arr[j], arr[j+1] = arr[j+1], arr[j]
        return arr

class QuickSort(SortStrategy):
    def sort(self, data):
        if len(data) <= 1:
            return data
        pivot = data[len(data) // 2]
        left = [x for x in data if x < pivot]
        middle = [x for x in data if x == pivot]
        right = [x for x in data if x > pivot]
        return self.sort(left) + middle + self.sort(right)

class Sorter:
    def __init__(self, strategy):
        self._strategy = strategy
    
    def sort(self, data):
        return self._strategy.sort(data)

# Usage
sorter = Sorter(QuickSort())
print(sorter.sort([3, 1, 4, 1, 5, 9, 2, 6]))

Practice

Implement a command pattern for a text editor.