策略模式

1、內容

定義一系列的演算法，把它們一個個封裝起來，並且使它們可相互替換。本模式使得演算法可獨立於使用它的客戶而變化。

2、角色

抽象策略（Strategy）

具體策略（ConcreteStrategy）

上下文（Context）

3、使用場景

許多相關的類僅僅是行為有異

需要使用一個演算法的不同變體

演算法使用了客戶端無需知道的資料

一個類中的多種行為以多個條件語句的形式存在，可以將這些行為封裝如不同的策略類中

**4、優點 **

定義了一系列可重用的演算法和行為

消除了一些條件語句

可以提供相同行為的不同實現

5、缺點

客戶必須瞭解不同的策略

策略與上下文之間的通訊開銷

增加了物件的數目

6、程式碼示例

from abc import ABCMeta, abstractmethod
import random

class Sort(metaclass=ABCMeta):
   @abstractmethod
   def sort(self, data):
       pass

class QuickSort(Sort):
   def quick_sort(self, data, left, right):
       if left < right:
           mid = self.partition(data, left, right)
           self.quick_sort(data, left, mid - 1)
           self.quick_sort(data, mid + 1, right)

   def partition(self, data, left, right):
       tmp = data[left]
       while left < right:
           while left < right and data[right] >= tmp:
               right -= 1
           data[left] = data[right]
           while left < right and data[left] <= tmp:
               left += 1
           data[right] = data[left]
       data[left] = tmp
       return left
   def sort(self, data):
       print("快速排序")
       return self.quick_sort(data, 0, len(data) - 1)

class MergeSort(Sort):
   def merge(self, data, low, mid, high):
       i = low
       j = mid + 1
       ltmp = []
       while i <= mid and j <= high:
           if data[i] <= data[j]:
               ltmp.append(data[i])
               i += 1
           else:
               ltmp.append(data[j])
               j += 1

       while i <= mid:
           ltmp.append(data[i])
           i += 1

       while j <= high:
           ltmp.append(data[j])
           j += 1

       data[low:high + 1] = ltmp

   def merge_sort(self, data, low, high):
       if low < high:
           mid = (low + high) // 2
           self.merge_sort(data, low, mid)
           self.merge_sort(data, mid + 1, high)
           self.merge(data, low, mid, high)

   def sort(self, data):
       print("歸併排序")
       return self.merge_sort(data, 0, len(data) - 1)

class Context:
   def __init__(self, data, strategy=None):
       self.data = data
       self.strategy = strategy

   def set_strategy(self, strategy):
       self.strategy = strategy

   def do_strategy(self):
       if self.strategy:
           self.strategy.sort(self.data)
       else:
           raise TypeError

li = list(range(100000))
random.shuffle(li)

context = Context(li, MergeSort())
context.do_strategy()
#print(context.data)

random.shuffle(context.data)

context.set_strategy(QuickSort())
context.do_strategy()
複製程式碼

識別圖中二維碼,領取python全套視訊資料