用程序模拟生活

随着社会的发展，时代的进步，出行的方式很多，地铁、快速公交、滴滴打车、共享单车等等，采用什么样的方式出行并不重要，重要的选择那种出现方式能准时到达目的地。

代码:

  1. from abc import ABCMeta, abstractmethod
  5. class IVehicle(metaclass=ABCMeta):
  6.     """交通工具的抽象类"""
  8.     @abstractmethod
  9.     def running(self):
  10.         pass
  14. class SharedBicycle(IVehicle):
  15.     """共享单车"""
  17.     def running(self):
  18.         print("骑共享单车(轻快便捷)", end="")
  22. class ExpressBus(IVehicle):
  23.     """快速公交车"""
  25.     def running(self):
  26.         print("坐快速公交车(绿色环保)", end="")
  29. class Express(IVehicle):
  30.     """快车"""
  32.     def running(self):
  33.         print("打快车(快速便捷)", end="")
  37. class Subway(IVehicle):
  38.     """地铁"""
  40.     def running(self):
  41.         print("坐地铁(安全高效)", end="")
  45. class Classmate:
  46.     """来聚餐的同学"""
  48.     def __init__(self, name, vechicle):
  49.         self.__name = name
  50.         self.__vechicle = vechicle
  53.     def attend_the_dinner(self):
  54.         print(self.__name + " ", end="")
  55.         self.__vechicle.running()
  56.         print(" 来聚餐! ")
  60. def test_the_dinner():
  61.     shared_bicycle = SharedBicycle()
  62.     joe = Classmate("Joe", shared_bicycle)
  63.     joe.attend_the_dinner()
  65.     subway = Subway()
  66.     helen = Classmate("Helen", subway)
  67.     helen.attend_the_dinner()
  69.     express_bus = ExpressBus()
  70.     henry = Classmate("Henry", express_bus)
  71.     henry.attend_the_dinner()
  73.     express = Express()
  74.     ruby = Classmate("Ruby", express)
  75.     ruby.attend_the_dinner()
  79. if __name__ == '__main__':
  80.     test_the_dinner()

什么是策略模式

定义一系列的算法，将每个算法都封装起来，并且使它们之间可以相互替换，策略模式使算法可以独立于使用它的用户变化。

策略模式设计思想

将不同的出行方式理解成一种出行算法，将这些算法抽象出一个基类IVehicle，并定义一系列算法、SharedBicycle 、ExpressBus、Express、Subway。我们可以选择任意种出行方式，并且可以方便地更换出行方式。
策略模式的核心思想是：对算法、规则进行封装，使得替换算法和新增算法更加灵活。

模型说明

策略模式中的主要有三个角色，在设计策略模式时要找到并区分角色。
1.上下文环境：起着承上启下的作用，屏蔽上层应用对策略的直接访问，封装可能存在变化。
2.策略抽象：策略(算法)的抽象类，定义统一的接口，规定每个子集类必须实现算法。
3.具备的策略： 策略的具体实现者，可以有多个不同的实现。

策略模式的优缺点

优点：
1.算法可以自由切换
2.避免使用多重条件判断
3.方便拓展和增加的算法
缺点：
1.所有算法策略的类都对外暴露。

实战

有一个Person类，有年龄(age)、身高(height)、体重(weight)三个属性。现在要对Person类的一组对象进行排序，但并没有确定用什么规则来排序，有时需要根据年龄进行排序，有时需要根据身高排序….

代码

  1. from abc import ABCMeta, abstractmethod
  5. class Person:
  6.     """人类"""
  8.     def __init__(self, name, age, weight, height):
  9.         self.name = name
  10.         self.age = age
  11.         self.weight = weight
  12.         self.height = height
  15.     def show_myself(self):
  16.         print("%s 年龄: %d 岁, 体重: %0.2fkg, 身高: %0.2fm" % (self.name, self.age, self.weight, self.height))
  20. class ICompare(metaclass=ABCMeta):
  21.     """比较算法"""
  23.     @abstractmethod
  24.     def comparable(self, person1, person2):
  25.         "person1 > person2 返回值 大于0, person1 == person2 返回0 person1 < person2 返回小于0"
  26.         pass
  30. class ComparableByAge(ICompare):
  31.     """通过年龄排序"""
  33.     def comparable(self, person1, person2):
  34.         return person1.age - person2.age
  38. class ComparaByHeight(ICompare):
  39.     """按身高排序"""
  41.     def comparable(self, person1, person2):
  42.         return person1.height - person2.height
  46. class ComparaByWeight(ICompare):
  47.     """按身高排序"""
  49.     def comparable(self, person1, person2):
  50.         return person1.weight - person2.weight
  54. class SortPerson:
  55.     """Person排序类"""
  57.     def __init__(self, compare):
  58.         self.__compare = compare
  61.     def sort(self,person_list):
  62.         """排序算法"""
  64.         n = len(person_list)
  65.         for i in range(0, n-1):
  66.             for j in range(0, n-i-1):
  67.                 if (self.__compare.comparable(person_list[j], person_list[j+1]) > 0):
  68.                     tmp = person_list[j]
  69.                     person_list[j] = person_list[j+1]
  70.                     person_list[j+1] = tmp
  71.                 j += 1
  72.             i += 1
  75. def test_sort_person():
  76.     person_list = [
  77.         Person("Tony", 2, 54.5, 0.82),
  78.         Person("Jack", 31, 74.5, 1.82),
  79.         Person("Nick", 54, 44.5, 1.59),
  80.         Person("Eric", 23, 62.5, 1.72),
  81.         Person("Helen", 16, 45.5, 1.60),
  82.     ]
  83.     print("根据年龄排序")
  84.     age_sort = SortPerson(ComparableByAge())
  85.     age_sort.sort(person_list)
  86.     for person in person_list:
  87.         person.show_myself()
  89.     print("根据身高排序")
  90.     height_sort = SortPerson(ComparaByHeight())
  91.     height_sort.sort(person_list)
  92.     for person in person_list:
  93.         person.show_myself()
  95.     print("根据体重排序")
  96.     weight_sort = SortPerson(ComparaByWeight())
  97.     weight_sort.sort(person_list)
  98.     for person in person_list:
  99.         person.show_myself()
  102. if __name__ == '__main__':
  103.     test_sort_person()

应用场景

1.如果系统里面有许多类，它们之间的区别仅在于有不同行为，那么可以使用策略模式动态地让一个对象在许多行为中选择一个。
2.一个系统需要动态地在几种算法中选择一种。
3.设计程序接口时希望部分内部实现由调用方自己实现。