[python]設計模式

需要說明：java跟python在思維模式上並不一樣，java利用接口以及多態可以實現很多抽象上的東西，而python不行，其實以下很多設計模式寫法並不適用也沒有必要，更多是為了對比和幫助理解這些設計模式，畢竟設計模式的核心是解耦。

 

1.單例模式

#-*- encoding=utf-8 -*-

class Singleton(object):
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)
        return cls._instance

a = Singleton()
b = Singleton()
print id(a)
print id(b)

 

2.模板模式

#coding:utf-8

class CaffeineBeverageWithHook(object):
    def prepareRecipe(self):
        self.boilWater()
        self.brew()
        self.pourInCup()
        if self.customerWantsCondiments():
            self.addCondiments()

    def brew(self):
        print "start brew."

    def addCondiments(self):
        pass

    def boilWater(self):
        print "start boilWater."

    def pourInCup(self):
        print "Pour into cup"

    def customerWantsCondiments(self):
        return False

class CoffeeWithHook(CaffeineBeverageWithHook):
    def brew(self):
        print "Dripping coffee through filter."

    def addCondiments(self):
        print "Add Sugar and Milk."

    def customerWantsCondiments(self):
        return True

if __name__ == '__main__':
    coffeeWithHook = CoffeeWithHook()
    coffeeWithHook.prepareRecipe()

 

3.適配器模式

#coding: utf-8

class Target(object):
    def request(self):
        print "this is target.request method."

class Adaptee(object):
    def special_request(self):
        print "this is Adaptee.special_request method."

class Adapter(object):
    def __init__(self):
        self.special_req = Adaptee()

    def request(self):
        self.special_req.special_request()


if __name__ == '__main__':
    adapter = Adapter()
    adapter.request()

 4.策略模式：在策略模式中遵循依賴倒置原則，使得策略在代碼運行時生效

# -*- coding: utf-8 -*-

class IStrategy(object):
    def doSomething(self):
        return

class ConcreteStrategy1(IStrategy):
    def doSomething(self):
        print "concreteStrategy 1"

class ConcreteStrategy2(IStrategy):
    def doSomething(self):
        print "concreteStrategy 2"

class Context(object):
    def __init__(self, concreteStrategy):
        self.strategy = concreteStrategy()

    def execute(self):
        self.strategy.doSomething()

if __name__ == '__main__':
    print "-----exec concreteStrategy 1-----"
    context = Context(ConcreteStrategy1)
    context.execute()

    print "-----exec concreteStrategy 2-----"
    context = Context(ConcreteStrategy2)
    context.execute()

 

5.工廠模式

#coding:utf-8
import sys
reload(sys)
sys.setdefaultencoding("utf-8")

class XMobile(object):
    def __init__(self, factory):
        self._factory = factory
    def order_mobile(self, brand):
        mobile = self._factory.create_mobile(brand)
        mobile.special_design()
        mobile.hardware()
        mobile.software()
        mobile.combine()
        mobile.box()

class MobileFactory(object):
    def create_mobile(self, brand):
        if brand == "Huawei":
            mobile = HuaweiProductLine(brand)
        elif brand == "Xiaomi":
            mobile = XiaomiProductLine(brand)
        elif brand == "Meizu":
            mobile = MeizuProductLine(brand)
        return mobile

class MobileProductLine(object):
    def __init__(self, brand):
        self.brand = brand

    def hardware(self):
        print "准備硬件"

    def software(self):
        print "准備軟件"

    def combine(self):
        print "合並手機"

    def box(self):
        print "封裝手機"

class HuaweiProductLine(MobileProductLine):
    def __init__(self, brand):
        super(HuaweiProductLine,self).__init__(brand)

    def special_design(self):
        print "使用Haisi CPU"

class XiaomiProductLine(MobileProductLine):
    def __init__(self, brand):
        super(XiaomiProductLine,self).__init__(brand)

    def special_design(self):
        print "使用MIUI"

class MeizuProductLine(MobileProductLine):
    def __init__(self, brand):
        super(MeizuProductLine,self).__init__(brand)

    def special_design(self):
        print "使用Flyme"

if __name__ == '__main__':
    mobileFactory = MobileFactory()
    xmobile = XMobile(mobileFactory)
    xmobile.order_mobile("Huawei")

 

6.觀察者模式

#coding:utf-8

class Subject(object):
    def __init__(self):
        self.obs_list = []    # observer對象

    def addObserver(self, obs):
        self.obs_list.append(obs)

    def delObserver(self, obs):
        self.obs_list.pop(obs)

    def notifyObserver(self):
        for obs in self.obs_list:
            obs.update()

    def doSomething(self):
        return

class ConcreteSubject(Subject):
    def __init__(self):
        super(ConcreteSubject, self).__init__()

    def doSomething(self):
        self.notifyObserver()

class Observer(object):
    def update(self):
        return

class ConcreteObserver1(Observer):
    def update(self):
        print "觀察者1收到信息，並進行處理。"

class ConcreteObserver2(Observer):
    def update(self):
        print "觀察者2收到信息，並進行處理。"

if __name__ == '__main__':
    concreteSubject = ConcreteSubject()
    concreteSubject.addObserver(ConcreteObserver1())
    concreteSubject.addObserver(ConcreteObserver2())
    concreteSubject.doSomething()

 

7.外觀模式

外觀模式是將一系列接口進行封裝，使得外層調用更加方便，因此不作說明

to be continue...