python中设计模式

1.工厂方法模式（Factory Method Pattern）：

定义了一个创建对象的接口，但由子类决定要实例化类的哪一个；即通过子类来创建对象。

工厂方法模式（Factory Method Pattern）：

定义了一个创建对象的接口，但由子类决定要实例化类的哪一个；即通过子类来创建对象。

原则：

要依赖抽象，不要依赖具体类。

案例：

先解释什么是工厂：
如果你开一家Pizza店（PizzaStore抽象类）卖各种风味的Pizza（Pizza子类），那么你需要根据客户要求准备相应的Pizza（创建Pizza对象），然后烘烤、切片、包装；
最简单的做法就是在PizzaStore中根据客户要求（类型判断）创建相应的Pizza对象，然后调用Pizza自身（由Pizza抽象类实现）的烘烤、切片和包装方法；
但这样的代码缺乏弹性，因为你让一个抽象类去依赖具体的对象；我们可以创建一个工厂来生产Pizza，根据传入的不同类型值返回不同Pizza对象，即从PizzaStore中将创建对象的代码挪到工厂中。但这只是一个编程技巧，并不算模式。

在工厂方法模式中，我们在PizzaStore中定义一个抽象接口（create_pizza）作为抽象的工厂，而order_pizza是它的客户；将Pizza对象的创建放到PizzaStore子类去解决。

现有Cheese和Clam两款Pizza，以及NY和Chicago两家分店，每家店的同款Pizza的口味不同——为迎合当地口味做了改进，主要差别来自不同的原材料，因此我们实现四个Pizza类型（NYStyleCheesePizza、NYStyleClamPizza、ChicagoStyleCheesePizza和ChicagoStyleClamPizza），每种使用不同的原材料组合，根据客户所在城市和选择款式我们创建不同的对象；根据工厂方法，我们将对象创建的代码放到PizzaStore子类去实现。

适用性：

当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

实现：

#!/usr/bin/python
#coding:utf8
'''
Factory Method
'''

class  ChinaGetter:
    """A simple localizer a la gettext"""
    def  __init__( self ):
        self .trans  =  dict (dog = u "小狗" , cat = u "小猫" )

    def  get( self , msgid):
        """We'll punt if we don't have a translation"""
        try :
            return  self .trans[msgid]
        except  KeyError:
            return  str (msgid)


class  EnglishGetter:
    """Simply echoes the msg ids"""
    def  get( self , msgid):
        return  str (msgid)


def  get_localizer(language = "English" ):
    """The factory method"""
    languages  =  dict (English = EnglishGetter, China = ChinaGetter)
    return  languages[language]()

# Create our localizers
e, g  =  get_localizer( "English" ), get_localizer( "China" )
# Localize some text
for  msgid  in  "dog parrot cat bear" .split():
    print (e.get(msgid), g.get(msgid))

2. Singleton（单例）

意图：

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

适用性：

当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

 

实现：

#!/usr/bin/python
#coding:utf8
'''
Singleton
'''

class  Singleton( object ):
    ''''' A python style singleton '''

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


if  __name__  = =  '__main__' :
    class  SingleSpam(Singleton):
        def  __init__( self , s):
            self .s  =  s

        def  __str__( self ):
            return  self .s


    s1  =  SingleSpam( 'spam' )
    print  id (s1), s1
    s2  =  SingleSpam( 'spa' )
    print  id (s2), s2
    print  id (s1), s1

3.Decorator（装饰）

意图： 
动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator 模式相比生成子类更为灵活。 
适用性：

 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

 处理那些可以撤消的职责。

当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

#!/usr/bin/python
#coding:utf8
'''
Decorator
'''

class  foo( object ):
    def  f1( self ):
        print ( "original f1" )

    def  f2( self ):
        print ( "original f2" )


class  foo_decorator( object ):
    def  __init__( self , decoratee):
        self ._decoratee  =  decoratee

    def  f1( self ):
        print ( "decorated f1" )
        self ._decoratee.f1()

    def  __getattr__( self , name):
        return  getattr ( self ._decoratee, name)

u  =  foo()
v  =  foo_decorator(u)
v.f1()
v.f2()

4. Proxy（代理）

意图：

 

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

 

适用性：

 在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用Proxy模式。下面是一 些可以使用Proxy 模式常见情况： 

1) 远程代理（Remote Proxy ）为一个对象在不同的地址空间提供局部代表。 NEXTSTEP[Add94] 使用NXProxy 类实现了这一目的。Coplien[Cop92] 称这种代理为“大使” （Ambassador ）。 
2 )虚代理（Virtual Proxy ）根据需要创建开销很大的对象。在动机一节描述的ImageProxy 就是这样一种代理的例子。 
3) 保护代理（Protection Proxy ）控制对原始对象的访问。保护代理用于对象应该有不同 的访问权限的时候。例如，在Choices 操作系统[ CIRM93]中KemelProxies为操作系统对象提供 了访问保护。 
4 )智能指引（Smart Reference ）取代了简单的指针，它在访问对象时执行一些附加操作。 它的典型用途包括：对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它(也称为SmartPointers[Ede92 ] )。

 当第一次引用一个持久对象时，将它装入内存。

 在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

#!/usr/bin/python
#coding:utf8
'''
Proxy
'''

import  time

class  SalesManager:
    def  work( self ):
        print ( "Sales Manager working..." )

    def  talk( self ):
        print ( "Sales Manager ready to talk" )

class  Proxy:
    def  __init__( self ):
        self .busy  =  'No'
        self .sales  =  None

    def  work( self ):
        print ( "Proxy checking for Sales Manager availability" )
        if  self .busy  = =  'No' :
            self .sales  =  SalesManager()
            time.sleep( 2 )
            self .sales.talk()
        else :
            time.sleep( 2 )
            print ( "Sales Manager is busy" )


if  __name__  = =  '__main__' :
    p  =  Proxy()
    p.work()
    p.busy  =  'Yes'
    p.work()