More Design Patterns

Strategy, command, adapter, and other patterns in Python.

Overview

Implement additional design patterns.

Strategy Pattern

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

class BubbleSort(SortStrategy):
    def sort(self, data):
        arr = data.copy()
        for i in range(len(arr)):
            for j in range(0, len(arr)-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)

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

Command Pattern

class Command:
    def execute(self):
        raise NotImplementedError
    
    def undo(self):
        raise NotImplementedError

class InsertCommand(Command):
    def __init__(self, document, text):
        self.document = document
        self.text = text
        self.position = len(document.text)
    
    def execute(self):
        self.document.insert(self.position, self.text)
    
    def undo(self):
        self.document.delete(self.position, len(self.text))

class Document:
    def __init__(self):
        self.text = ""
        self.history = []
    
    def execute(self, command):
        command.execute()
        self.history.append(command)
    
    def undo(self):
        if self.history:
            self.history.pop().undo()

Adapter Pattern

class EuropeanSocket:
    def connect(self, voltage):
        return f"Connected at {voltage}V"

class AmericanSocket:
    def plug_in_type_a(self, voltage):
        return f"Connected at {voltage}V via Type A"

class Adapter:
    def __init__(self, socket):
        self.socket = socket
    
    def connect(self, voltage):
        if isinstance(self.socket, AmericanSocket):
            return self.socket.plug_in_type_a(voltage)
        return self.socket.connect(voltage)

euro = EuropeanSocket()
adapter = Adapter(euro)
print(adapter.connect(220))  # Connected at 220V

Practice

Implement a decorator pattern for a coffee shop order system.