常用设计模式Python实现

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

代码查看：https://github.com/nonpricklycactus/Design-Pattern

一、设计模式分类

            经典的《设计模式》一书归纳出23种设计模式，这23种模式又可归为，创建型、结构型和行为型3大类

            1.创建型模式分类

               社会化的分工越来越细，自然在软件设计方面也是如此，因此对象的创建和对象的使用分开也就成为了必然趋势。因为对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进行研究，从而能够高效地创建对象就是创建型模式要探讨的问题。这里有6个具体的创建型模式可供研究，它们分别是：

• 简单工厂模式（Simple Factory）；
• 工厂方法模式（Factory Method）；
• 抽象工厂模式（Abstract Factory）；
• 创建者模式（Builder）；
• 原型模式（Prototype）；
• 单例模式（Singleton）。

说明：严格来说，简单工厂模式不是GoF总结出来的23种设计模式之一。

           2. 结构型模式分类

               在解决了对象的创建问题之后，对象的组成以及对象之间的依赖关系就成了开发人员关注的焦点，因为如何设计对象的结构、继承和依赖关系会影响到后续程序的维护性、代码的健壮性、耦合性等。对象结构的设计很容易体现出设计人员水平的高低，这里有7个具体的结构型模式可供研究，它们分别是：

• 外观模式（Facade）；
• 适配器模式（Adapter）；
• 代理模式（Proxy）；
• 装饰模式（Decorator）；
• 桥模式（Bridge）；
• 组合模式（Composite）；
• 享元模式（Flyweight

           3. 行为型模式分类

                在对象的结构和对象的创建问题都解决了之后，就剩下对象的行为问题了，如果对象的行为设计的好，那么对象的行为就会更清晰，它们之间的协作效率就会提高，这里有11个具体的行为型模式可供研究，它们分别是：

• 模板方法模式（Template Method）；
• 观察者模式（Observer）；
• 状态模式（State）；
• 策略模式（Strategy）；
• 职责链模式（Chain of Responsibility）；
• 命令模式（Command）；
• 访问者模式（Visitor）；
• 调停者模式（Mediator）；
• 备忘录模式（Memento）；
• 迭代器模式（Iterator）；
• 解释器模式（Interpreter）

二、设计模式的六大原则

           1、开闭原则（Open Close Principle）

                 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

           2、里氏代换原则（Liskov Substitution Principle）

                 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

            3、依赖倒转原则（Dependence Inversion Principle）

                   这个是开闭原则的基础，具体内容：是对接口编程，依赖于抽象而不依赖于具体。

             4、接口隔离原则（Interface Segregation Principle）

                    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

              5、迪米特法则（最少知道原则）（Demeter Principle）

                    为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

              6、合成复用原则（Composite Reuse Principle）

                     原则是尽量使用合成/聚合的方式，而不是使用继承。

三、常用创建型模式实现

           1.工厂模式

              在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

              

             该例子为通过ShapeFactory对象调用Shape接口实现图形的画出

             python代码实现：简单工厂.py

工厂方法模式

             

                简单工厂模式只有一个工厂，工厂方法模式对每一个产品都有相应的工厂

                该例子为通过提供的接口基类创建要调用运算类的运算工厂，对运算类的子类进行调用，通过该方法增加一个运算类（例如N次方类），只需要增加运算类和相对应的工厂，两个类，不需要修改工厂类。

                python代码实现：工厂模式.py

抽象工厂模式

                  抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。

                  所谓产品族，是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的主板、芯片组、CPU组成一个家族，Intel的主板、芯片组、CPU组成一个家族。而这两个家族都来自于三个产品等级：主板、芯片组、CPU。一个等级结构是由相同的结构的产品组成，示意图如下：

               通过使用抽象工厂模式，可以处理具有相同（或者相似）等级结构中的多个产品族中的产品对象的创建问题。如下图所示：

             由于这两个产品族的等级结构相同，因此使用同一个工厂族也可以处理这两个产品族的创建问题，这就是抽象工厂模式。

             抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口。一定要注意，这个接口内的方法不是任意堆砌的，而是一系列相关或相互依赖的方法。

在什么情况下应当使用抽象工厂模式

• 　一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
• 　这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
• 　同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。（比如：Intel主板必须使用Intel CPU、Intel芯片组）
• 　系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

           python代码实现：抽象工厂模式.py

      2.建造者模式

          将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

          python代码实现：建造者模式 

    3.单例模式

         保证一个类仅有一个实例，并提供一个访问它的全局访问点。

#实现__new__方法
#并在将一个类的实例绑定到类变量_instance上,
#如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
#如果cls._instance不为None,直接返回cls._instance
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            orig = super(Singleton,cls)
            cls._instance =  orig.__new__(cls)
        return cls._instance
 
class MyClass(Singleton):
    def __init__(self,name):
        self.name = name
 
 
a = MyClass("Alex")
b = MyClass("Jack")
 
 
print(a.name)
print(b.name)

 四、常用结构型模式实现

            1.适配器模式

               将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 

               python代码实现：适配器模式.py

            2.桥接模式

                 将抽象部分与实现部分分离，使它们都可以独立的变化。 

             python代码实现：桥接模式.py

             深入讲解请参考：http://www.cnblogs.com/houleixx/archive/2008/02/23/1078877.html

           3.组合模式

              将对象组合成树形结构以表示“部分-整体”的层次结构。C o m p o s i t e 使得用户对单个对象和组合对象的使用具有一致性。 

              

                python代码实现：组合模式.py

           4.外观模式

               为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

                python代码实现：外观模式.py

           5.享元模式

                运用共享技术有效地支持大量细粒度的对象。

                python代码实现：享元模式.py

           6.代理模式

                为其他对象提供一种代理以控制对这个对象的访问。

                主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

                 python代码实现：代理模式.py​​​​​​​

五、常用行为型模式实现

           1.模板方法模式

                定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

                主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

               python代码实现：模板模式.py​​​​​​​

           2.责任链模式

                 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

                python代码实现：责任链.py​​​​​​​

           3.观察者模式

               定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

                python代码实现：观察者模式.py​​​​​​​

           4.策略模式

               定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

               主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

                 python代码实现：策略模式.py