Python的设计模式编程入门指南

有没有想过设计模式到底是什么?通过本文可以看到设计模式为什么这么重要,通过几个Python的示例展示为什么需要设计模式,以及如何使用。
设计模式是什么?

设计模式是经过总结、优化的,对我们经常会碰到的一些编程问题的可重用解决方案。一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码。反之,设计模式更为高级,它是一种必须在特定情形下实现的一种方法模板。设计模式不会绑定具体的编程语言。一个好的设计模式应该能够用大部分编程语言实现(如果做不到全部的话,具体取决于语言特性)。最为重要的是,设计模式也是一把双刃剑,如果设计模式被用在不恰当的情形下将会造成灾难,进而带来无穷的麻烦。然而如果设计模式在正确的时间被用在正确地地方,它将是你的救星。

起初,你会认为“模式”就是为了解决一类特定问题而特别想出来的明智之举。说的没错,看起来的确是通过很多人一起工作,从不同的角度看待问题进而形成的一个最通用、最灵活的解决方案。也许这些问题你曾经见过或是曾经解决过,但是你的解决方案很可能没有模式这么完备。

虽然被称为“设计模式”,但是它们同“设计“领域并非紧密联系。设计模式同传统意义上的分析、设计与实现不同,事实上设计模式将一个完整的理念根植于程序中,所以它可能出现在分析阶段或是更高层的设计阶段。很有趣的是因为设计模式的具体体现是程序代码,因此可能会让你认为它不会在具体实现阶段之前出现(事实上在进入具体实现阶段之前你都没有意识到正在使用具体的设计模式)。

可以通过程序设计的基本概念来理解模式:增加一个抽象层。抽象一个事物就是隔离任何具体细节,这么做的目的是为了将那些不变的核心部分从其他细节中分离出来。当你发现你程序中的某些部分经常因为某些原因改动,而你不想让这些改动的部分引发其他部分的改动,这时候你就需要思考那些不会变动的设计方法了。这么做不仅会使代码可维护性更高,而且会让代码更易于理解,从而降低开发成本。

设计出一个优雅的、易于维护的程序难点在于发现我所说的“变化的向量”(在这里,“向量”指的是最大的梯度变化方向(maximum gradient),而并非指一个容器类)。意思是找出系统中变化的最重要的部分,或者换句话说,发现影响系统最大的花销在哪里。一旦你发现了变化的向量,你就可以围绕这个重点设计你的程序。

所以设计模式的目的就是分离代码中的可变部分。如果你这么去审视这个问题,你会立刻看到多个设计模式。举个例子,面向对象的继承(inheritance)可以看做一种设计模式(虽然是由编译器实现的)。它允许通过同样的接口(不变的部分)来表现不同的行为(变化的部分)。组合也可以被认为是一种设计模式,因为它允许通过动态或静态的方式改变实现类的对象以及他们的行为。

另一个常见的设计模式例子是迭代器。迭代器自Python出现伊始就已经随for循环的使用而存在了,并且在Python2.2版本的时候被明确成为其一个特性。一个迭代器隐藏了容器内部的具体实现,提供一个依次访问容器对象内每个元素的方式。所以,你能够使用通用的代码对一个序列的每个元素做对应操作而不用去理会此序列是怎么建立的。所以你的代码能够对任何能够产生迭代器的对象有效。

这里列举了三种最基本的设计模式:

  1. 结构化模式,通常用来处理实体之间的关系,使得这些实体能够更好地协同工作。
  2. 创建模式,提供实例化的方法,为适合的状况提供相应的对象创建方法。
  3. 行为模式,用于在不同的实体建进行通信,为实体之间的通信提供更容易,更灵活的通信方法。

我们为什么要使用设计模式?

从理论上来说,设计模式是对程序问题比较好的解决方案。无数的程序员都曾经遇到过这些问题,并且他们使用这些解决方案去处理这些问题。所以当你遇到同样的问题,为什么要去想着创建一个解决方案而不是用现成的并且被证明是有效的呢?
例子

假定现在有一个任务,需要你找到一个有效的方法合并两个做不同事情的类,在已有系统中这两个类在许多不同的地方被大量使用,所以移除这两个类或是改动已有的代码都是异常困难的。不仅如此,更改已有的代码会导致大量的测试工作,因为在这样一种依赖大量不同组件的系统中,这些修改总是会引入一些新的错误。为了避免这些麻烦,你可以实现一个策略模式(Strategy Pattern)和适配器模式(Adapter Pattern)的变体,这两种模式能够很好的处理这种问题。

class StrategyAndAdapterExampleClass():

  def __init__(self, context, class_one, class_two):
    self.context = context
    self.class_one = class_one
    self.class_two = class_two

  def operation1(self):
    if self.context == "Context_For_Class_One":
      self.class_one.operation1_in_class_one_context()
    else:
      self.class_two.operational_in_class_two_context()

很简单是吧?现在让我们来仔细研究一下策略模式。
策略模式

策略模式是一种与行为相关的设计模式,允许你在运行时根据指定的上下文确定程序的动作。你可以在两个类中封装不同的算法,并且在程序运行时确定到底执行哪种策略。

在上面的例子中,策略是根据实例化时context变量的值来决定的。如果给定context变量的值是“class_one”,将会执行class_one,否则就会执行class_two。
我在那里使用它?

假定你现在正在写一个类能够更新或创建一条新的用户记录,接收同样的输入参数(诸如姓名、地址、手机号等),但是根据不同的情况会调用对应的更新或是创建方法。当然,你可能会用一个if-else判断处理这个问题,但是如果你需要在不同的地方使用这个类呢?那么你就得不停地重写if-else判断。为什么不简单地通过指定上下文来解决这个问题。

class User():
  def create_or_update(self, name, address, mobile, userid=None):
    if userid:
      # it means the user doesn't exist yet, create a new record
    else:
      # it means the user already exists, just update based on the given userid

常规的策略模式涉及到将算法封装到另一个类中,但如果这样的话,那个类就太浪费了。切记不要死记模板,把握住核心概念灵活的变通,最重要是解决问题。

适配器模式

适配器模式是一个结构性的设计模式,允许通过不同的接口为一个类赋予新的用途,这使得使用不同调用方式的系统都能够使用这个类。

也可以让你改变通过客户端类接收到的输入参数以适应被适配者的相关函数。
怎么使用?

另一个使用适配器类的地方是包装器(wrapper),允许你将一个动作包装成为一个类,然后可以在合适的情形下复用这个类。一个典型的例子是当你为一个table类簇创建一个domain类时,你能够将所有的对应不同表的相同动作封装成为一个适配器类,而不是一个接一个的单独调用这些不同的动作。这不仅使得你能够重用你想要的所有操作,而且当你在不同的地方使用同样的动作时不用重写代码。

比较一下两种实现:
不用适配器的方案

class User(object):
  def create_or_update(self):
    pass

class Profile(object):
  def create_or_update(self):
    pass

user = User()
user.create_or_update()

profile = Profile()
profile.create_or_update()

如果我们需要在不同的地方做同样的事,或是在不同的项目中重用这段代码,那么我们需要重新敲一遍。
使用包装类的解决方案

看看我们怎么反其道而行:

account_domain = Account()
account_domain.NewAccount()

在这种情况下,我们通过一个包装类来实现账户domain类:

class User(object):
  def create_or_update(self):
    pass

class Profile(object):
  def create_or_update(self):
    pass

class Account():
  def new_account(self):
    user = User()
    user.create_or_update()

    profile = Profile()
    profile.create_or_update()

这样的话,你就能够在你需要的时候使用账户domain了,你也可以将其他的类包装到domain类下。
工厂模式

工厂模式是一种创建型的设计模式,作用如其名称:这是一个就像工厂那样生产对象实例的类。

这个模式的主要目的是将可能涉及到很多类的对象创建过程封装到一个单独的方法中。通过给定的上下文输出指定的对象实例。
什么时候使用?

使用工厂模式的最佳时机就是当你需要使用到单个实体的多个变体时。举个例子,你有一个按钮类,这个按钮类有多种变体,例如图片按钮、输入框按钮或是flash按钮等。那么在不同的场合你会需要创建不同的按钮,这时候就可以通过一个工厂来创建不同的按钮。

让我们先来创建三个类:

class Button(object):
  html = ""
  def get_html(self):
    return self.html

class Image(Button):
  html = "<img alt="" />"

class Input(Button):
  html = "<input type="text" />"

class Flash(Button):
  html = ""

然后创建我们的工厂类:

class ButtonFactory():
  def create_button(self, typ):
    targetclass = typ.capitalize()
    return globals()[targetclass]()

译注:globals()将以字典的方式返回所有全局变量,因此targetclass = typ.capitalize()将通过传入的typ字符串得到类名(Image、Input或Flash),而globals()[targetclass]将通过类名取到类的类(见元类),而globals()[targetclass]()将创建此类的对象。

我们可以这么使用工厂类:

button_obj = ButtonFactory()
button = ['image', 'input', 'flash']
for b in button:
  print button_obj.create_button(b).get_html()

输出将是所有按钮类型的HTML属性。这样骂你就能够根据不同的情况指定不同类型的按钮了,并且很易于重用。
装饰器模式

装饰器模式是一个结构性模式,允许我们根据情况,在运行时为一个对象添加新的或附加的行为。

目的是为给一个特定的对象实例应用扩展的函数方法,并且同时也能够产生没有新方法的原对象。它允许多装饰器结合用于一个实例,所以你就不会出现实例同单个装饰器相捆绑的情况了。这个模式是实现子类继承外的一个可选方式,子类继承是指从父类集成相应的功能。与子类继承必须在编译时添加相应的行为不同,装饰器允许你在运行时根据需要添加新的行为。

可以根据以下步骤实现装饰器模式:

  1. 以原组件类为基类创建装饰器类。
  2. 在装饰器类中添加一个组件类的指针域
  3. 将一个组件传递给装饰器类的构造器以初始化组件类指针
  4. 在装饰器类中,将所有的组件方法指向组件类指针,并且,
  5. 在装饰器类中,重写每个需要修改功能的组件方法。

相关维基百科(http://en.wikipedia.org/wiki/Decorator_pattern)
什么时候使用?

使用装饰器模式的最佳时机是当你有一个根据情况需要添加新的行为的实体时。假设你有一个HTML链接元素,一个登出链接,并且你希望根据当前页面对具体的行为做微小的改动。这种情况下,我们可以使用装饰器模式。

首先,建立我们所需要的装饰模式。

如果我们在主页并且已经登录,那么将登出链接用h2标签标记。

如果我们在不同的页面并且已经登录,那么用下划线标签标记链接

如果已登录,用加粗标记链接。

一旦建立了装饰模式,我们就可以开工了。

class HtmlLinks():
  def set_html(self, html):
    self.html = html

  def get_html(self):
    return self.html

  def render(self):
    print(self.html)

class LogoutLink(HtmlLinks):
  def __init__(self):
    self.html = "<a href="logout.html"> Logout </a>"

class LogoutLinkH2Decorator(HtmlLinks):
  def __init__(self, logout_link):
    self.logout_link = logout_link
    self.set_html(" {0} ".format(self.logout_link.get_html()))

  def call(self, name, args):
    self.logout_link.name(args[0])

class LogoutLinkUnderlineDecorator(HtmlLinks):
  def __init__(self, logout_link):
    self.logout_link = logout_link
    self.set_html(" {0} ".format(self.logout_link.get_html()))

  def call(self, name, args):
    self.logout_link.name(args[0])

class LogoutLinkStrongDecorator(HtmlLinks):
  def __init__(self, logout_link):
    self.logout_link = logout_link
    self.set_html("<strong> {0} </strong>".format(self.logout_link.get_html()))

  def call(self, name, args):
    self.logout_link.name(args[0])

logout_link = LogoutLink()
is_logged_in = 0
in_home_page = 0

if is_logged_in:
  logout_link = LogoutLinkStrongDecorator(logout_link)
if in_home_page:
  logout_link = LogoutLinkH2Decorator(logout_link)
else:
  logout_link = LogoutLinkUnderlineDecorator(logout_link)

logout_link.render()

单例模式

单例模式是一个创建型的设计模式,功能是确保运行时对某个类只存在单个实例对象,并且提供一个全局的访问点来访问这个实例对象。

因为对于调用单例的其他对象而言这个全局唯一的访问点“协调”了对单例对象的访问请求,所以这些调用者看到的单例内变量都将是同一份。
什么时候能够使用?

单例模式可能是最简单的设计模式了,它提供特定类型的唯一对象。为了实现这个目标,你必须控制程序之外的对象生成。一个方便的方法是将一个私有内部类的单个对象作为单例对象。

class OnlyOne:
  class __OnlyOne:
    def __init__(self, arg):
      self.val = arg
    def __str__(self):
      return repr(self) + self.val
  instance = None
  def __init__(self, arg):
    if not OnlyOne.instance:
      OnlyOne.instance = OnlyOne.__OnlyOne(arg)
    else:
      OnlyOne.instance.val = arg
  def __getattr__(self, name):
    return getattr(self.instance, name)

x = OnlyOne('sausage')
print(x)
y = OnlyOne('eggs')
print(y)
z = OnlyOne('spam')
print(z)
print(x)
print(y)
print(`x`)
print(`y`)
print(`z`)
output = '''
<__main__.__OnlyOne instance at 0076B7AC>sausage
<__main__.__OnlyOne instance at 0076B7AC>eggs
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.OnlyOne instance at 0076C54C>
<__main__.OnlyOne instance at 0076DAAC>
<__main__.OnlyOne instance at 0076AA3C>
'''

因为内置类是用双下划线开始命名,所以它是私有的,用户无法直接访问。内置类包含了所有你希望放在普通类中的方法,并且通过外层包装类的构造器控制其创建。当第一次你创建OnlyOne时,初始化一个实例对象,后面则会忽略创建新实例的请求。

通过代理的方式进行访问,使用__getattr__()方法将所有调用指向单例。你可以从输出看到虽然看起来好像创建了多个对象(OnlyOne),但 __OnlyOne对象只有一个。虽然OnlyOne实例有多个,但他们都是唯一的 __OnlyOne对象的代理。

请注意上面的方法并没有限制你只能创建一个对象,这也是一个创建有限个对象池的技术。然而在那种情况下,你可能会遇到共享池内对象的问题。如果这真是一个问题,那你可以通过为共享对象设计签入“check-in”和迁出“check-out”机制来解决这个问题。
总结

在本文中,我只列举了几个我再编程中觉得十分重要的设计模式来讲,除此之外还有很多设计模式需要学习。如果你对其他的设计模式感兴趣,维基百科的设计模式部分可以提供很多信息。如果还嫌不够,你可以看看四人帮的《设计模式:可复用面向对象软件的基础》一书,此书是关于设计模式的经典之作。

最后一件事:当使用设计模式时,确保你是用来解决正确地问题。正如我之前提到的,设计模式是把双刃剑:如果使用不当,它们会造成潜在的问题;如果使用得当,它们则将是不可或缺的。

时间: 2015-04-01

Python单例模式实例分析

本文实例讲述了Python单例模式的使用方法.分享给大家供大家参考.具体如下: 方法一 复制代码 代码如下: import threading    class Singleton(object):      __instance = None        __lock = threading.Lock()   # used to synchronize code        def __init__(self):          "disable the __init__ method&

Python设计模式之观察者模式实例

关于设计模式中的观察者模式,定义如下(维基百科): 觀察者模式(有時又被稱為發布/訂閱模式)是軟體設計模式的一種.在此種模式中,一個目標物件管理所有相依於它的觀察者物件,並且在它本身的狀態改變時主動發出通知.這通常透過呼叫各觀察者所提供的方法來實現.此種模式通常被用來實作事件處理系統.简单来说,一个被观察者有很多观察者,被观察者的状态的改变会引起所有观察者的响应操作. 那么我们用Python2.7来实现观察者模式. Python中的集合set 集合(set),类似于列表(list),但是它没有重

Python单例模式实例详解

本文实例讲述了Python单例模式.分享给大家供大家参考,具体如下: 单例模式:保证一个类仅有一个实例,并提供一个访问他的全局访问点. 实现某个类只有一个实例的途径: 1,让一个全局变量使得一个对象被访问,但是他不能防止外部实例化多个对象. 2,让类自身保存他的唯一实例,这个类可以保证没有其他实例可以被创建. 多线程时的单例模式:加锁-双重锁定 饿汉式单例类:在类被加载时就将自己实例化(静态初始化).其优点是躲避了多线程访问的安全性问题,缺点是提前占用系统资源. 懒汉式单例类:在第一次被引用时,

Python设计模式之代理模式实例

翻墙常用的方式就是使用代理(Proxy),其基本过程如下: 浏览器<-->代理服务器<-->服务器 如果浏览器请求不到服务器,或者服务器无法响应浏览器,我们可以设定将浏览器的请求传递给代理服务器,代理服务器将请求转发给服务器.然后,代理服务器将服务器的响应内容传递给浏览器.当然,代理服务器在得到请求或者响应内容的时候,本身也可以做些处理,例如缓存静态内容以加速,或者说提取请求内容或者响应内容做些正当或者不正当的分析.这种翻墙方式,就是设计模式中代理模式(Proxy Pattern)

Python设计模式之单例模式实例

注:使用的是Python 2.7. 一个简单实现 复制代码 代码如下: class Foo(object):    __instance = None    def __init__(self):        pass    @classmethod    def getinstance(cls):        if(cls.__instance == None):            cls.__instance = Foo()        return cls.__instance

详解python单例模式与metaclass

单例模式的实现方式 将类实例绑定到类变量上 class Singleton(object): _instance = None def __new__(cls, *args): if not isinstance(cls._instance, cls): cls._instance = super(Singleton, cls).__new__(cls, *args) return cls._instance 但是子类在继承后可以重写__new__以失去单例特性 class D(Singleto

5种Python单例模式的实现方式

本文为大家分享了Python创建单例模式的5种常用方法,供大家参考,具体内容如下 所谓单例,是指一个类的实例从始至终只能被创建一次. 方法1: 如果想使得某个类从始至终最多只有一个实例,使用__new__方法会很简单.Python中类是通过__new__来创建实例的: class Singleton(object): def __new__(cls,*args,**kwargs): if not hasattr(cls,'_inst'): cls._inst=super(Singleton,cl

常见的在Python中实现单例模式的三种方法

单例模式是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单例类的特殊类.通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源.如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案. 单例模式的要点有三个:一是某个类只能有一个实例:二是它必须自行创建这个实例:三是它必须自行向整个系统提供这个实例.在Python中,单例模式有以下几种实现方式. 方法一.实现__new__方法,然后将类的一个实例绑定到类变量_instanc

Python下singleton模式的实现方法

很多开发人员在刚开始学Python 时,都考虑过像 c++ 那样来实现 singleton 模式,但后来会发现 c++ 是 c++,Python 是 Python,不能简单的进行模仿. Python 中常见的方法是借助 global 变量,或者 class 变量来实现单件.本文就介绍以decorator来实现 singleton 模式的方法.示例代码如下: ##----------------------- code begin ----------------------- # -*- cod

Python设计模式中单例模式的实现及在Tornado中的应用

单例模式的实现方式 将类实例绑定到类变量上 class Singleton(object): _instance = None def __new__(cls, *args): if not isinstance(cls._instance, cls): cls._instance = super(Singleton, cls).__new__(cls, *args) return cls._instance 但是子类在继承后可以重写__new__以失去单例特性 class D(Singleto

python设计模式大全

本文实例讲述了python常见的设计模式.分享给大家供大家参考,具体如下: # #!/usr/bin/env python # # -*- coding:utf-8 # # class HttpBase: # def get(self): # psss # class Http1(HttpBase): # def get(self): # print 'http1' # class Http2(HttpBase): # def get(self): # print 'http2' # # # c

Python设计模式之MVC模式简单示例

本文实例讲述了Python设计模式之MVC模式.分享给大家供大家参考,具体如下: 一.简单介绍 mvc模式  the  model-view-controller pattern mvc模式是一个运用在软件工程中的设计模式.mvc模式脱离了以前简单的web服务设计逻辑,将开发,测试和维护分离.在MVC模式中,应用被分解为相互作用的模块,模型,视图,控制.目的在于分离输入(control),处理逻辑(model),输出格式(view). 简单的理解: 1. 控制模块用于获取用户输入,并将模型与视图

Python设计模式之命令模式简单示例

本文实例讲述了Python设计模式之命令模式.分享给大家供大家参考,具体如下: 命令模式介绍: 在面向对象编程中,命令模式是概括所有方法信息的设计模式. 此模式对象包涵方法名,及其相关参数值. 命令模式是一个分类的观察者设计模式,在命令模式下,对象被概括为一个命令表单,此表单包涵了所有用户需要的方法. 举个例子:如果有个按钮是用户接口"red",当被触碰的时候,会启动后台的"turn red"接口.现在用户并不知道,通过什么类或者方法的接口能够让后台处理"

Python设计模式之观察者模式简单示例

本文实例讲述了Python设计模式之观察者模式.分享给大家供大家参考,具体如下: 观察者模式是一个软件设计模式,一个主题对象包涵一系列依赖他的观察者,自动通知观察者的主题对象的改变,通常会调用每个观察者的一个方法.这个设计模式非常适用于分布式事件处理系统. 典型的在观察者模式下: 1.发布者类应该包涵如下方法: 注册能够接收通知的对象 从主对象到注册对象,通知任何变化 未注册对象不能够接收任何通知信息 2.订购者类应该包涵如下: 发布者会调用一个订购者提供的方法,将任何改变告知注册对象. 3.当

Python设计模式之门面模式简单示例

本文实例讲述了Python设计模式之门面模式.分享给大家供大家参考,具体如下: facade:建筑物的表面 门面模式是一个软件工程设计模式,主要用于面向对象编程. 一个门面可以看作是为大段代码提供简单接口的对象,就像类库. 门面模式被归入建筑设计模式.门面模式隐藏系统内部的细节和复杂度,给用户提供一个简单的接口,采用门面模式,用户能够使用简单的接口进行工作,而不用担心系统的复杂. 理解门面模式最重要的一点就是它提供的简单接口是系统的一部分.因此提供简单易用的功能要胜过完整的功能. 门面模式的优点

Python设计模式之中介模式简单示例

本文实例讲述了Python设计模式之中介模式.分享给大家供大家参考,具体如下: Mediator Pattern:中介模式 中介模式提供了一系列统一的系统接口.此模式也被认为是行为模式,因为他能选择程序处理流程. 当许多类开始在交互中产生结果时,可以选用中介模式.当软件开始组织的时候,许多用户的要求添加更多的功能. 这就导致了要和以前的类不断交互,除了新类.随着系统的复杂度加大,类之间的交互变得频繁,维护代码变得困难. 中介模式 就是为了解决这个问题,通过允许类之间的松耦合.这样中介模式就能了解

Python设计模式之代理模式简单示例

本文实例讲述了Python设计模式之代理模式.分享给大家供大家参考,具体如下: 代理模式在一般形式上是一个类函数接口.代理可以是这些事物的接口:网络连接,存储的对象,文件,或者其他资源(昂贵的或者不容易复制的). 一个众所周知的代理模式的例子就是引用计数的指针对象. 代理模式是结构设计模式的例子.这个模式的目的是要创建一个真实对象或类的代理. 代理模式有3个必要的元素: 1. 真实的对象(执行业务逻辑,被代理的对象) 2. 代理类(用户请求的一个接口,对真实目标的保护) 3. 用户(获取任务的用

Python设计模式之工厂模式简单示例

本文实例讲述了Python设计模式之工厂模式.分享给大家供大家参考,具体如下: 工厂模式是一个在软件开发中用来创建对象的设计模式. 工厂模式包涵一个超类.这个超类提供一个抽象化的接口来创建一个特定类型的对象,而不是决定哪个对象可以被创建. 为了实现此方法,需要创建一个工厂类创建并返回. 当程序运行输入一个"类型"的时候,需要创建于此相应的对象.这就用到了工厂模式.在如此情形中,实现代码基于工厂模式,可以达到可扩展,可维护的代码.当增加一个新的类型,不在需要修改已存在的类,只增加能够产生

Python设计模式之建造者模式实例详解

本文实例讲述了Python设计模式之建造者模式.分享给大家供大家参考,具体如下: 建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 下面是一个建造者模式的demo #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ 大话设计模式 设计模式--建造者模式 建造者模式(Builder):将一个复杂对象的构建与它的表示分离,使得

Python设计模式之解释器模式原理与用法实例分析

本文实例讲述了Python设计模式之解释器模式原理与用法.分享给大家供大家参考,具体如下: 解释器模式(Interpreter Pattern):给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 下面是一个解释器模式的demo: #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ 大话设计模式 设计模式--解释器模式 解释器模式(Interpr