Python设计模式 (代码实现)

一、设计模式分类

创建类设计模式	单例模式、工厂模式、建造者模式、原型模式
结构类设计模式	装饰器模式、适配器模式、门面模式、代理模式、组合模式、享元模式、桥梁模式
行为类模式	策略模式、责任链模式、命令模式、中介者模式、模板模式、迭代器模式、访问者模式、观察者模式、解释器模式、备忘录模式、状态模式

 

二、创建类设计模式

1、单例模式

单例模式就是确保一个类只有一个实例.当你希望整个系统中,某个类只有一个实例时,单例模式就派上了用场.
比如,某个服务器的配置信息存在在一个文件中,客户端通过AppConfig类来读取配置文件的信息.如果程序的运行的过程中,很多地方都会用到配置文件信息,则就需要创建很多的AppConfig实例,这样就导致内存中有很多AppConfig对象的实例,造成资源的浪费.其实这个时候AppConfig我们希望它只有一份,就可以使用单例模式.

只介绍一种基于__new__方法实现的单例模式（推荐使用，方便）。

import threading, time


class Singleton(object):
    def __init__(self, *args, **kwargs):
        time.sleep(1)
        pass
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super().__new__(cls)
            return cls._instance

def task(arg):
    obj = Singleton()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task, args=[i, ])
    t.start()


<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>

问题出现了！按照以上方式创建的单例，无法支持多线程，因为最先执行的线程卡在init中，还没有实例化出_instance。所以其他线程依然可以正常实例化对象。

如何解决呢？ 加锁：

import threading, time


class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self, *args, **kwargs):
        time.sleep(1)
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            with cls._instance_lock:
                if not hasattr(cls, '_instance'):
                    cls._instance = super().__new__(cls)

            return cls._instance


obj1 = Singleton()
obj2 = Singleton()
print(obj1, obj2)


def task(arg):
    obj = Singleton()
    print(obj)


for i in range(10):
    t = threading.Thread(target=task, args=[i, ])
    t.start()

博主实际开发中的应用：利用第三方SDK发短信功能、简历敏感信息屏蔽功能，两者都是基于celery异步任务，无需考虑多线程。

 

2、工厂模式

工厂模式包涵一个超类。这个超类提供一个抽象化的接口来创建一个特定类型的对象，而不是决定哪个对象可以被创建。

当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工厂模式。在如此情形中，实现代码基于工厂模式，可以达到可扩展，可维护的代码。当增加一个新的类型，不在需要修改已存在的类，只增加能够产生新类型的子类。

class Person:
    def __init__(self):
        self.name = None
        self.gender = None

    def getName(self):
        return self.name

    def getGender(self):
        return self.gender

class Male(Person):
    def __init__(self, name):
        print "Hello Mr." + name

class Female(Person):
    def __init__(self, name):
        print "Hello Miss." + name

class Factory:
    def getPerson(self, name, gender):
        if gender == 'M':
                return Male(name)
        if gender == 'F':
            return Female(name)


if __name__ == '__main__':
    factory = Factory()
    person = factory.getPerson("Chetan", "M")

博主实际开发中的应用：django、flask项目配置文件根据prod、uat、dev环境的不同而使用不同的配置（最典型）。

 

3、建造者模式

建造者模式的定义如下：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式的作用，就是将“构建”和“表示”分离，以达到解耦的作用。

在建造者模式中，还可以加一个Director类，用以安排已有模块的构造步骤。对于在建造者中有比较严格的顺序要求时，该类会有比较大的用处

一个例子更能很好的理解以上的内容：

1. 有一个接口类，定义创建对象的方法。一个指挥员类，接受创造者对象为参数。两个创造者类，创建对象方法相同，内部创建可自定义

2.一个指挥员，两个创造者(瘦子 胖子)，指挥员可以指定由哪个创造者来创造

from abc import ABCMeta, abstractmethod


class Builder():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw_left_arm(self):
        pass
    @abstractmethod
    def draw_right_arm(self):
        pass
    @abstractmethod
    def draw_left_foot(self):
        pass
    @abstractmethod
    def draw_right_foot(self):
        pass
    @abstractmethod
    def draw_head(self):
        pass
    @abstractmethod
    def draw_body(self):
        pass


class Thin(Builder):
    def draw_left_arm(self):
        print '画左手'
    def draw_right_arm(self):
        print '画右手'
    def draw_left_foot(self):
        print '画左脚'
    def draw_right_foot(self):
        print '画右脚'
    def draw_head(self):
        print '画头'
    def draw_body(self):
        print '画瘦身体'


class Fat(Builder):
    def draw_left_arm(self):
        print '画左手'
    def draw_right_arm(self):
        print '画右手'
    def draw_left_foot(self):
        print '画左脚'
    def draw_right_foot(self):
        print '画右脚'
    def draw_head(self):
        print '画头'
    def draw_body(self):
        print '画胖身体'


class Director():
    def __init__(self, person):
        self.person=person

    def draw(self):
        self.person.draw_left_arm()
        self.person.draw_right_arm()
        self.person.draw_left_foot()
        self.person.draw_right_foot()
        self.person.draw_head()
        self.person.draw_body()


if __name__=='__main__':
    thin=Thin()
    fat=Fat()
    director_thin=Director(thin)
    director_thin.draw()
    director_fat=Director(fat)
    director_fat.draw()

 

4、原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式本质就是克隆对象，所以在对象初始化操作比较复杂的情况下，很实用，能大大降低耗时，提高性能，因为“不用重新初始化对象，而是动态地获得对象运行时的状态”。

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

 

三、结构类设计模式

1、装饰器模式

动态地给一个对象添加一些额外的职责。在增加功能方面，装饰器模式比生成子类更为灵活。

实现很简单，这里不介绍。

 

2、门面模式

在面向对象程序设计中，解耦是一种推崇的理念。但事实上由于某些系统中过于复杂，从而增加了客户端与子系统之间的耦合度。例如：在家观看多媒体影院时，更希望按下一个按钮就能实现影碟机，电视，音响的协同工作，而不是说每个机器都要操作一遍。这种情况下可以采用外观模式，即引入一个类对子系统进行包装，让客户端与其进行交互。

门面模式(Facade Pattern)：外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观模式又称为门面模式，它是一种对象结构型模式。

例如：有一组火警报警系统，由三个子元件构成：一个警报器，一个喷水器，一个自动拨打电话的装置。

class AlarmSensor:
    def run(self):
        print "Alarm Ring..."
class WaterSprinker:
    def run(self):
        print "Spray Water..."
class EmergencyDialer:
    def run(self):
        print "Dial 119..."

class EmergencyFacade:  # 门面
    def __init__(self):
        self.alarm_sensor=AlarmSensor()
        self.water_sprinker=WaterSprinker()
        self.emergency_dialer=EmergencyDialer()
    def runAll(self):
        self.alarm_sensor.run()
        self.water_sprinker.run()
        self.emergency_dialer.run()

if __name__=="__main__":
    emergency_facade=EmergencyFacade()
    emergency_facade.runAll()

博主实际开发中的应用：PDF心电报告生成过程、简历文件内容提取过程。

 

2、适配器模式

将一个类的接口变换成客户端期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。适配器模式和装饰模式有一定的相似性，都起包装的作用，但二者本质上又是不同的，装饰模式的结果，是给一个对象增加了一些额外的职责，而适配器模式，则是将另一个对象进行了“伪装”。

假设某公司A与某公司B需要合作，公司A需要访问公司B的人员信息，但公司A与公司B协议接口不同，该如何处理？

为在A公司平台复用B公司接口，直接调用B公司人员接口是个办法，但会对现在业务流程造成不确定的风险。为减少耦合，规避风险，我们需要一个帮手，就像是转换电器电压的适配器一样，这个帮手就是协议和接口转换的适配器。适配器构造如下：】

class ACpnStaff:
    name=""
    id=""
    phone=""
    def __init__(self,id):
        self.id=id
    def getName(self):
        print "A protocol getName method...id:%s"%self.id
        return self.name
    def setName(self,name):
        print "A protocol setName method...id:%s"%self.id
        self.name=name
    def getPhone(self):
        print "A protocol getPhone method...id:%s"%self.id
        return self.phone
    def setPhone(self,phone):
        print "A protocol setPhone method...id:%s"%self.id
        self.phone=phone
class BCpnStaff:
    name=""
    id=""
    telephone=""
    def __init__(self,id):
        self.id=id
    def get_name(self):
        print "B protocol get_name method...id:%s"%self.id
        return self.name
    def set_name(self,name):
        print "B protocol set_name method...id:%s"%self.id
        self.name=name
    def get_telephone(self):
        print "B protocol get_telephone method...id:%s"%self.id
        return self.telephone
    def set_telephone(self,telephone):
        print "B protocol get_name method...id:%s"%self.id
        self.telephone=telephone

class CpnStaffAdapter:
    b_cpn=""
    def __init__(self,id):
        self.b_cpn=BCpnStaff(id)
    def getName(self):
        return self.b_cpn.get_name()
    def getPhone(self):
        return self.b_cpn.get_telephone()
    def setName(self,name):
        self.b_cpn.set_name(name)
    def setPhone(self,phone):
        self.b_cpn.set_telephone(phone)

 

3、代理模式

代理模式是一种使用频率非常高的模式，在多个著名的开源软件和当前多个著名的互联网产品后台程序中都有所应用。下面我们用一个抽象化的简单例子，来说明代理模式。
首先，构造一个网络服务器：

class Server:
    content=""
    def recv(self,info):
        pass
    def send(self,info):
        pass
    def show(self):
        pass
class infoServer(Server):
    def recv(self,info):
        self.content=info
        return "recv OK!"
    def send(self,info):
        pass
    def show(self):
        print "SHOW:%s"%self.content

那么，如何给这个服务器设置一个白名单，使得只有白名单里的地址可以访问服务器呢？修改Server结构是个方法，但这显然不符合软件设计原则中的单一职责原则。在此基础之上，使用代理，是个不错的方法。代理配置如下：

class serverProxy:
    pass
class infoServerProxy(serverProxy):
    server=""
    def __init__(self,server):
        self.server=server
    def recv(self,info):
        return self.server.recv(info)
    def show(self):
        self.server.show()

class whiteInfoServerProxy(infoServerProxy):
    white_list=[]
    def recv(self,info):
        try:
            assert type(info)==dict
        except:
            return "info structure is not correct"
        addr=info.get("addr",0)
        if not addr in self.white_list:
            return "Your address is not in the white list."
        else:
            content=info.get("content","")
            return self.server.recv(content)
    def addWhite(self,addr):
        self.white_list.append(addr)
    def rmvWhite(self,addr):
        self.white_list.remove(addr)
    def clearWhite(self):
        self.white_list=[]

代理中有一个server字段，控制代理的服务器对象，infoServerProxy充当Server的直接接口代理，而whiteInfoServerProxy直接继承了infoServerProxy对象，同时加入了white_list和对白名单的操作。这样，在场景中通过对白名单代理的访问，就可以实现服务器的白名单访问了。

要仔细体会ServerProxy、InfoServerProxy、WhiteInfoServerProxy三者的层级关系。为什么不将所有功能封装在WhiteInfoServerProxy中。

 

4、组合模式

将对象组合成成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性.

# 抽象一个组织类
class Component(object):
    def __init__(self, name):
        self.name = name
    def add(self,comp):
        pass
    def remove(self,comp):
        pass
    def display(self, depth):
        pass

# 叶子节点
class Leaf(Component):
    def add(self,comp):
        print '不能添加下级节点'
    def remove(self,comp):
        print '不能删除下级节点'
    def display(self, depth):
        strtemp = ''
        for i in range(depth):
            strtemp += strtemp+'-'
        print strtemp+self.name


# 枝节点
class Composite(Component):
    def __init__(self, name):
        self.name = name
        self.children = []
    def add(self,comp):
        self.children.append(comp)
    def remove(self,comp):
        self.children.remove(comp)
    def display(self, depth):
        strtemp = ''
        for i in range(depth):
            strtemp += strtemp+'-'
        print strtemp+self.name
        for comp in self.children:
            comp.display(depth+2)

if __name__ == "__main__":
    #生成树根
    root = Composite("root")
    #根上长出2个叶子
    root.add(Leaf('leaf A'))
    root.add(Leaf('leaf B'))

    #根上长出树枝Composite X
    comp = Composite("Composite X")
    comp.add(Leaf('leaf XA'))
    comp.add(Leaf('leaf XB'))
    root.add(comp)

    #根上长出树枝Composite X
    comp2 = Composite("Composite XY")
    #Composite X长出2个叶子
    comp2.add(Leaf('leaf XYA'))
    comp2.add(Leaf('leaf XYB'))
    root.add(comp2)
    # 根上又长出2个叶子,C和D,D没张昊,掉了
    root.add(Leaf('Leaf C'))
    leaf = Leaf("Leaf D")
    root.add(leaf)
    root.remove(leaf)
    #展示组织
    root.display(1)

 

5、享元模式

享元模式是一种用于解决资源和性能压力时会使用到的设计模式，它的核心思想是通过引入数据共享来提升性能。

在开发3D游戏时，例如有成千上万的士兵或者有成千上万棵树，如果一个3D地带的每个对象都单独创建，不使用数据共享，那么性能是无法接受的。

　　故享元设计模式就是通过为相似对象映入数据共享来最小化内存的使用，提升性能。

　　既然要创建成千上万个士兵，那么若他们的数据属性行为都是一样的，那岂不是黏一块去了。这时候就会有：可变数据和不可变数据的概念。

　　即 -- 重点在于将不可变（可共享）的属性与可变的属性区分开。相同类型的对象共享不可变（可共享）的数据，而每个对象又有其独立的数据，这部分数据即为：可变的属性（不可共享数据）。

其实享元模式的实现与单例模式的实现方式十分相似，比如：单例模式实现的是一个类对象只允许有一个实例对象，而享元模式则是一个类对象只允许创建不同类型的对象，这样保证同一类型的对象共享不可变数据。

import random
from enum import Enum


TreeType = Enum('TreeType','apple_tree cherry_tree peach_tree')

class Tree:
    pool = dict()

    def __new__(cls, tree_type, *args,**kwargs):
        obj = cls.pool.get(tree_type,None)
        if not obj:
            obj = super().__new__(cls,*args, **kwargs)
            cls.pool[tree_type] = obj
            obj.tree_type = tree_type
        return obj

    def __init(self,size ):
        self.size = size
    
    def render(self,age,x,y):
        print('render a tree of type {} and age {} at ({},{})'.format(self.tree_type,age,x,y))




def main():
    rnd = random.Random()
    age_min, age_max = 1, 30
    min_piont, max_point = 0, 100
    tree_counter = 0

    for _ in range(10):
        t1 = Tree(TreeType.apple_tree)
        t1.render(rnd.randint(age_min, age_max),
                rnd.randint(min_piont, max_point),
                rnd.randint(min_piont, max_point)
        )
        tree_counter += 1
    
    for _ in range(3):
        t1 = Tree(TreeType.cherry_tree)
        t1.render(rnd.randint(age_min, age_max),
                rnd.randint(min_piont, max_point),
                rnd.randint(min_piont, max_point)
        )
        tree_counter += 1
    
    for _ in range(5):
        t1 = Tree(TreeType.peach_tree)
        t1.render(rnd.randint(age_min, age_max),
                rnd.randint(min_piont, max_point),
                rnd.randint(min_piont, max_point)
        )
        tree_counter += 1
    
    print(Tree.pool)

if __name__ == '__main__':
    main()

其实可以发现同一类型的树对象，其ID均一样，而其size属性却不一样，这是由于在执行__init__方法时，返回类型池中的对象后，在进行初始化会size属性会覆盖前面返回的对象的size属性值。

　　总结：

　　该示例中，在__new__方法中实现类不可变数据的共享。

　　　　　　　在__init__方法中实现了可变数据的独立，即不共享。

 

6、桥梁模式

将抽象与实现解耦（注意此处的抽象和实现，并非抽象类和实现类的那种关系，而是一种角色的关系，这里需要好好区分一下），可以使其独立变化。在形如上例中，Pen只负责画，但没有形状，它终究是不知道要画什么的，所以我们把它叫做抽象化角色；而Shape是具体的形状，我们把它叫做实现化角色。抽象化角色和实现化角色是解耦的，这也就意味着，所谓的桥，就是抽象化角色的抽象类和实现化角色的抽象类之间的引用关系。

# 形状抽象层
class Shape:
    name=""
    param=""
    def __init__(self,*param):
        pass
    def getName(self):
        return self.name
    def getParam(self):
        return self.name,self.param
# 画笔抽象层
class Pen:
    shape=""
    type=""
    def __init__(self,shape):
        self.shape=shape
    def draw(self):
        pass

# 构造矩形形状
class Rectangle(Shape):
    def __init__(self,long,width):
        self.name="Rectangle"
        self.param="Long:%s Width:%s"%(long,width)
        print "Create a rectangle:%s"%self.param
# 构造圆形形状
class Circle(Shape):
    def __init__(self,radius):
        self.name="Circle"
        self.param="Radius:%s"%radius
        print "Create a circle:%s"%self.param

#构造常规画笔
class NormalPen(Pen):
    def __init__(self,shape):
        Pen.__init__(self,shape)
        self.type="Normal Line"
    def draw(self):
        print "DRAWING %s:%s----PARAMS:%s"%(self.type,self.shape.getName(),self.shape.getParam())
#构造刷画笔
class BrushPen(Pen):
    def __init__(self,shape):
        Pen.__init__(self,shape)
        self.type="Brush Line"
    def draw(self):
        print "DRAWING %s:%s----PARAMS:%s" % (self.type,self.shape.getName(), self.shape.getParam())


if __name__=="__main__":
    normal_pen=NormalPen(Rectangle("20cm","10cm"))
    brush_pen=BrushPen(Circle("15cm"))
    normal_pen.draw()
    brush_pen.draw()