Implement the Strategy Pattern with Interchangeable Algorithm Classes in Python

from abc import ABC, abstractmethod
from typing import List


class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: List[int]) -> List[int]:
        pass


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


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


class SortContext:
    def __init__(self, strategy: SortStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: SortStrategy) -> None:
        self._strategy = strategy

    def execute_sort(self, data: List[int]) -> List[int]:
        return self._strategy.sort(data)


if __name__ == "__main__":
    numbers = [5, 2, 9, 1, 7, 3]

    context = SortContext(BubbleSort())
    print("Bubble sort:", context.execute_sort(numbers))

    context.set_strategy(QuickSort())
    print("Quick sort: ", context.execute_sort(numbers))