——————假设写一款游戏————————-

假设 我们现在要写一款游戏，首先是要先设定角色的基础属性的数值，比如

  1. class Knight(object):
  2.     def __init__(self, life, speed, attack_power, attack_range, weapon):
  3.         self.life = life
  4.         self.speed = speed
  5.         self.attack_power = attack_power
  6.         self.attack_range = attack_range
  7.         self.weapon = weapon
  9.     def __str__(self):
  10.         return 'Life: {0} \n' \
  11.                'Attack: {1} \n' \
  12.                'Attack Range: {2} \n' \
  13.                'Speed: {3} \n' \
  14.                'Weapon: {4}'.format(
  15.                                     self.life,
  16.                                     self.attack_power,
  17.                                     self.attack_range,
  18.                                     self.speed,
  19.                                     self.weapon
  20.                                     )

此时，我们拥有了第一个基础单位类Knight，接下来是要实现生成Knight，那么我们就需要一个兵营

  1. class Barracks(object):
  2.     def generate_knight(self):
  3.         return Knight(400, 5, 3, 1, "short sword")
  5. if __name__ == '__main__':
  6.     barracks = Barracks()
  7.     knight1 = barracks.generate_kngiht()
  8.     print("[knight1]", kngiht1)

此时我们就生成了我们第一个knight实例，生命值400，速度5，攻击力3，攻击距离1，武器是短剑。
那么我们现在可以思考这么一点，这个单位如果要升级的话 那么代码是要怎么去写呢？为计划在特定兵营中生成的每一种单位类型使用一个独立函数并非一个好主意。
举个例子，假设我们考虑升级knight类，让他的武器不再是短剑而且长剑，攻击力+5，速度+3，攻击范围扩大+1，那么我们就需要在Barracks类中使用双倍数量的函数，并且需要保留这个类所能生成的兵营和单位的状态的某种记录，以确保生成正确级别的单位
那么为了解决这种困局，可以命名一个名为 generate_unit的方法来替换单独的gennerate_knight，话不多说，直接上代码

我们可以看到，该代码生成了一个级别为2的骑士，并且独立参数符合我们的预期，不需要Barracks类保持追踪每个单位的每个级别以及与之相关的参数。

———————实现原型模式————————

以上只是开胃菜，为了能够让大家更清楚的理解什么时候适合用原型模式来编写代码
例如此时我们有一个需求， 兵营1级时，只能创建骑士level1， 升级至2级兵营时， 骑士可以升级为2级骑士，并且解锁弓箭手。
那么每次一个兵营想要创建一个单位时，它都需要查找它所能创建的单位是哪些，然后发出一条命令来创建所选择的单位。然后单位类就必须要查询相关的参数，之后，在这些参数被传递到要创建的实例的类构造器前，会先读取这些参数，所有这些都是非常低效的。如果一个兵营必须生成类型相同的500个单位，我们就必须对所选的存储系统进行499次重复请求。在用这一数字乘以兵营的数量，然后外加上每个兵营判定其应该有能力生成的单位所需进行的查找。那么目前的做法将马上让系统宕机。
每次都重新加载这些对象的做法并非是可拓展的解决方案，而解决这个问题的办法就是 原型模式

原型模式

在原型模式中，我们优先使用组合而非继承。由各个部分组成的类使得我们可以在运行时替换那些组成部分，从而彻底地改善系统的可测试性和可维护性。要实例化的类是在运行时经由动态加载指定的。原型模式的这一特性的结果就是，子类的应用会显著减少。创建一个新实例的复杂性对客户端是隐藏起来的。所有这一切都很棒，不过这一模式的主要优点在于，它会强制我们面向接口变成，这会带来更好的设计
不过要注意一点，深层克隆的具有循环引用的类必定会引发问题。

现在我们仅希望对我们手头伤的一些对象复制一个副本，要确保该副本是以其应有的方式来设置的，并且为了将该对象的功能从系统其余部分隔离出来，我们打算复制的实例应该提供该复制特性。在该实例上克隆该对象并且之后相应修改其值的clone（）方法会是理想的。
原型模式所需的三个组成部分如下：
客户端通过要求原型克隆其资深来创建一个新的对象
原型声明一个用于克隆自己的接口
具体原型实现用于克隆其自身的操作

（浅拷贝与深拷贝的对比在此不再多说）

就其核心而言，原型模式就是一个clone()函数，这个函数接受一个对象做为输入参数并且会返回它的一个副本。
一个原型模式实现的框架应该声明一个抽象基类，这个基类会指定一个纯虚方法clone()。任何需要多态构造函数能力的类都会从该抽象类派生其本身，并且实现这个clone方法。

  1. # Prototype.py
  2. from abc import ABCMeta, abstractmethod
  5. class Prototype(metaclass=ABCMeta):
  7.     @abstractmethod
  8.     def clone(self):
  9.         pass
  1. # rts_prototype.py
  2. from config.linshijiekou import Prototype
  3. from copy import deepcopy
  6. class Knight(Prototype):
  7.     def __init__(self, level):
  8.         self.unit_type = 'knight'
  9.         if level == 1:
  10.             self.life = 500
  11.             self.attack = 15
  12.             self.attack_range = 2
  13.             self.speed = 15
  14.             self.weapon = 'Sword'
  15.         elif level == 2:
  16.             self.life = 999
  17.             self.attack = 30
  18.             self.attack_range = 4
  19.             self.speed = 20
  20.             self.weapon = " Gold Sword"
  22.     def __str__(self):
  23.         return 'Type: {0} \n' \
  24.                'Life: {1} \n' \
  25.                'Attack: {2} \n' \
  26.                'Attack Range: {3} \n' \
  27.                'Speed: {4} \n' \
  28.                'Weapon: {5}'.format(self.unit_type,
  29.                                     self.life,
  30.                                     self.attack,
  31.                                     self.attack_range,
  32.                                     self.speed,
  33.                                     self.weapon
  34.                                     )
  36.     def clone(self):
  37.         return deepcopy(self)
  40. class Archer(Prototype):
  41.     def __init__(self, level):
  42.         self.unit_type = 'archer'
  43.         if level == 1:
  44.             self.life = 500
  45.             self.attack = 15
  46.             self.attack_range = 2
  47.             self.speed = 15
  48.             self.weapon = 'Short Bow'
  49.         elif level == 2:
  50.             self.life = 999
  51.             self.attack = 30
  52.             self.attack_range = 4
  53.             self.speed = 20
  54.             self.weapon = " Gold Bow"
  56.     def __str__(self):
  57.         return 'Type: {0} \n' \
  58.                'Life: {1} \n' \
  59.                'Attack: {2} \n' \
  60.                'Attack Range: {3} \n' \
  61.                'Speed: {4} \n' \
  62.                'Weapon: {5}'.format(self.unit_type,
  63.                                     self.life,
  64.                                     self.attack,
  65.                                     self.attack_range,
  66.                                     self.speed,
  67.                                     self.weapon
  68.                                     )
  70.     def clone(self):
  71.         return deepcopy(self)
  74. class Barracks(object):
  75.     def __init__(self):
  76.         self.units = {
  77.             'knight': {
  78.                 1: Knight(1),
  79.                 2: Knight(2)
  80.             },
  81.             'archer': {
  82.                 1: Archer(1),
  83.                 2: Archer(2)
  84.             }
  85.         }
  87.     def build_unit(self, unit_type, level):
  88.         return self.units[unit_type][level].clone()
  91. if __name__ == '__main__':
  92.     barracks = Barracks()
  93.     knight1 = barracks.build_unit('knight', 2)
  94.     archer1 = barracks.build_unit('archer', 1)
  95.     print("[knight1]", knight1)
  96.     print("[archer1]", archer1)

在这些单位类中扩展该抽象基类时，会强制我们实现该clone方法，我们在让兵营生成新的单位时需要使用它。
现在，可以直接克隆具有正确级别的单位，而不必打开一个文件或从外部资源加载任何数据