浅谈Python设计模式 - 原型模式

　声明，本系列文章主要参考《精通Python设计模式》一书，并且参考一些资料，结合自己的一些看法来总结而来。

　在《精通Python设计模式》中把设计模式分为三种类型：

• 创建型模式
• 结构型模式
• 行为型模式

　本篇主要介绍关于 创建型模式的一种，书上的说法为：

当我们已有一个对象，并希望创建该对象的一个完整副本时，原型模式就派上用场了。在我们知道对象的某些部分会被变更但又希望保持原有对象不变之时，通常需要对象的一个副本。在这样的案例中，重新创建原有对象是没有意义的（请参考网页［ Mitotic division ］）。
另一个案例是，当我们想复制一个复杂对象时，使用原型模式会很方便。对于复制复杂对象，我们可以将对象当作是从数据库中获取的，并引用其他一些也是从数据库中获取的对象。若通过多次重复查询数据来创建一个对象，则要做很多工作。在这种场景下使用原型模式要方便得多。

　 个人理解：

　　当我们已经存在一个对象，这个对象有其属性和方法，若我们还想去获得另外一个同类型对象，此时有两种选择：重新去创建一个新的对象，或者 根据已有的对象复制一个副本，而在很多时候我们不需要完全去重新构建一个对象，只需要在原有对象存在的基础上（保留原对象），去修改其属性和方法得到一个新的对象。　

　  其实通俗解释来说：

　　比如：当我们出版了一本书《Python 设计模式 1.0版》，若10 年后我们觉得这本书跟不上时代了，这时候需要去重写一本《Python 设计模式 2.0版》，那么我们是完全重写一本书呢？还是在原有《Python 设计模式 1.0版》的基础上进行修改呢？当然是后者，这样会省去很多排版、添加原有知识等已经做过的工作。

　

　　接下来看一下书中的示例源码：

import copy
from collections import OrderedDict

class Book:
    def __init__(self, name, authors, price, **rest):
        '''rest的例子有：出版商、长度、标签、出版日期'''
        self.name = name
        self.authors = authors
        self.price = price
        self.__dict__.update(rest)      # 添加其他额外属性

    def __str__(self):
        mylist = []
        ordered = OrderedDict(sorted(self.__dict__.items()))
        for i in ordered.keys():
            mylist.append('{}: {}'.format(i, ordered[i]))
            if i == 'price':
                mylist.append('$')
            mylist.append('\n')
        return ''.join(mylist)

class Prototype:
    def __init__(self):
        self.objects = dict()    # 初始化一个原型列表

    def register(self, identifier, obj):
        # 在原型列表中注册原型对象
        self.objects[identifier] = obj

    def unregister(self, identifier):
        # 从原型列表中删除原型对象
        del self.objects[identifier]

    def clone(self, identifier, **attr):
        # 根据 identifier 在原型列表中查找原型对象并克隆
        found = self.objects.get(identifier)
        if not found:
            raise ValueError('Incorrect object identifier: {}'.format(identifier))
        obj = copy.deepcopy(found)
        obj.__dict__.update(attr)   # 用新的属性值替换原型对象中的对应属性
        return obj

def main():
    b1 = Book('The C Programming Language', ('Brian W. Kernighan', 'Dennis M.Ritchie'),
    price=118, publisher='Prentice Hall', length=228, publication_date='1978-02-22',
    tags=('C', 'programming', 'algorithms', 'data structures'))

    prototype = Prototype()
    cid = 'k&r-first'
    prototype.register(cid, b1)
    b2 = prototype.clone(cid, name='The C Programming Language(ANSI)', price=48.99, length=274, publication_date='1988-04-01', edition=2)

    for i in (b1, b2):
        print(i)
    print("ID b1 : {} != ID b2 : {}".format(id(b1), id(b2)))

if __name__ == '__main__':
    main()

　　其输出结果为：

authors: ('Brian W. Kernighan', 'Dennis M.Ritchie')
length: 228
name: The C Programming Language
price: 118$
publication_date: 1978-02-22
publisher: Prentice Hall
tags: ('C', 'programming', 'algorithms', 'data structures')

authors: ('Brian W. Kernighan', 'Dennis M.Ritchie')
edition: 2
length: 274
name: The C Programming Language(ANSI)
price: 48.99$

publication_date: 1988-04-01
publisher: Prentice Hall
tags: ('C', 'programming', 'algorithms', 'data structures')

ID b1 : 2378797084512 != ID b2 : 2378796684008

　　

　　其实这段代码在 Python 中，我们要实现一样的效果，并没有这么复杂，完全可以不使用这样的方法，我们更熟悉的方法是这样的，这里只修改 main 函数：

def main():
    b1 = Book('The C Programming Language',
              ('Brian W. Kernighan', 'Dennis M.Ritchie'),
              price=118,
              publisher='Prentice Hall',
              length=228,
              publication_date='1978-02-22',
              tags=('C', 'programming', 'algorithms', 'data structures'))

    # 这里我们彻底抛弃之前的原型设计模式的写法

    b2 = copy.deepcopy(b1)
    b2.name = 'The C Programming Language(ANSI)'
    b2.price = 48.99
    b2.length = 274
    b2.publication_date = '1988-04-01'
    b2.edition = 2

    for i in (b1, b2):
        print(i)
    print("ID b1 : {} != ID b2 : {}".format(id(b1), id(b2)))

　　

　　所以说：同样的内容，经过不同的方式，可以得到同样的效果。

　《Python设计模式》中也提及到，大概意思如下：

　　设计模式不会绑定具体的编程语言。一个好的设计模式应该能够用大部分编程语言实现(如果做不到全部的话，具体取决于语言特性)。最为重要的是，设计模式也是一把双刃剑，如果设计模式被用在不恰当的情形下将会造成灾难，进而带来无穷的麻烦。然而如果设计模式在正确的时间被用在正确地地方，它将是你的救星。

　　这里不是说书中实例的原型模式没有用，而是说 有些时候可以用简单粗暴的方式实现，何必整的那么弯弯绕绕呢？当然，视情况而定吧。

　　over~~~~~~~~