Tutorialspoint Python 设计模式教程

原创 yBmZlQzJ 2023-06-15

338

Tutorialspoint Python 设计模式教程

来源：易百教程

Python设计模式™

本教程以Python脚本语言来学习各种类型的设计模式及其实现。本教程将通过使用Python概念的不同方法和示例引导您完成相关设计模式。

Python设计模式

面向读者

本教程旨在为程序员和开发人员的基础和中级水平带来益处。

前提条件

在继续本教程之前，假设读者已经了解了基本的python编程概念。如果没有Python编程基础，可以通过以下链接学习:http://www.yiibai.com/python/

问题反馈

我们不能保证您在学习此 Python设计模式教程的过程中不会遇到任何问题。本教程中的讲解，示例和代码等只是根据作者的理解来概括写出。由于作者水平和能力有限，因此不保正所有编写的文章都准确无误。但是如果有遇到任何错误或问题，请反馈给我们，我们会及时纠正以方便后续读者阅读。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

Python设计模式简介 - Python设计模式™

设计模式用于表示开发人员用来创建软件或Web应用程序的模式。根据需求分析选择这些模式。这些模式描述了问题的解决方案，何时何地应用解决方案以及实施的结果。

设计模式的结构

设计模式文档的维护方式更侧重于所使用的技术以及以何种方式。下图解释了设计模式文档的基本结构。

模式名称(Pattern Name) - 它以简短而有效的方式描述了模式。
意图/动机(Intent/Motive) - 它描述了模式的功能。
适用性(Applicability) - 它描述了模式适用的情况列表。
参与者和后果(Participants and consequences) - 参与者包括参与设计模式的类和对象，并列出模式中存在的后果列表。

为什么使用Python？

Python是一种开源的脚本语言。它有支持各种设计模式的库。 Python的语法很容易理解，并使用英文语法作为关键字。

Python为下面提到的设计模式列表提供支持。这些设计模式将在本教程中学习和使用 -

模型视图控制器模式
单身模式
工厂模式
生成器模式
原型模式
门面模式
命令模式
适配器模式
原型模式
装饰模式
代理模式
责任链模式
观察者模式
状态模式
策略模式
模板模式
享元模式
抽象工厂模式
面向对象模式

使用设计模式的好处

以下是设计模式的一些优点 -

模式为开发人员提供了针对指定问题的久经考验的解决方案。
所有设计模式都是语言中立的。
模式有助于实现沟通并保持良好的文档。
它包含一项成就记录，以减少项目的任何技术风险。
设计模式使用起来非常灵活且易于理解。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

Python设计模式概要 - Python设计模式™

Python是一种开源的脚本语言，它是高级的，解释的，交互式的和面向对象的。它被设计成具有高度可读性。Python语言的语法很容易理解，并且经常使用英语关键字。

Python语言的特点

在本节中，我们将学习Python语言的不同特性。

1．解释
Python在运行时使用解释器进行处理。执行前无需编译程序。它类似于PERL和PHP。

2. 面向对象
Python遵循面向对象的风格和设计模式。它包含了类封装，多态等多种特性的类定义。

3. 可移植
使用Windows操作系统编写的Python代码，可在Mac操作系统中运行。该代码可以根据需求重用和移植。

4. 易于编码
Python语法很容易理解和编码。任何开发人员都可以在几个小时内理解Python的语法。 Python可以被描述为“程序员友好”的编程语言。

5. 扩展

如果需要，用户也可以用C语言编写一些Python代码。也可以将源代码中的Python代码放入像C++这样的其它语言中。这使得Python成为一种可扩展的语言。

要点

下面是与Python编程语言相关的重要问题 -

它包括功能和结构化编程方法以及面向对象编程方法。
它可以用作脚本语言或编程语言。
它包括自动垃圾收集。
它包含高级动态数据类型并支持各种动态类型检查。
Python包含与C，C++和Java等语言进行集成的功能。

如何下载和安装python语言？

要在您的系统中下载Python语言，请点击此链接 -

https://www.python.org/downloads/

它包括用于Windows，MacOS和Linux发行版等各种操作系统的软件包。

Python重要工具

在本节中，我们将简要介绍Python中的一些重要工具。

Python字符串

字符串的基本声明如下 -

str = 'Hello World!'

Python列表

Python的列表可以声明为复合数据类型，用逗号分隔，并用方括号([])括起来。

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

Python元组

元组是Python的动态数据类型，它由多个用逗号分隔的值组成。元组括在括号中。

tinytuple = (123, 'john')

Python字典
Python字典是一种散列表。字典的键可以是几乎任何Python的数据类型。键的数据类型通常是数字或字符串。

tinydict = {'name': 'maxsu','code':6734, 'dept': 'sales'}

构成Python的设计模式是什么？

Python有助于使用以下参数构建设计模式 -

模式名称
意图
别名
动机
问题
解决
结构体
参与者
约束
示例代码

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

模型视图控制器（MVC）模式 - Python设计模式™

模型视图控制器(MVC)是最常用的设计模式。开发人员发现很容易实现这种设计模式。

以下是模型视图控制器(MVC)的基本架构 -

现在让我们看看这个模式结构是如何工作的。

模型(Model)

它由纯粹的应用程序逻辑组成，它与数据库交互。它包含了向最终用户呈现数据的所有信息。

视图(View)

视图代表与最终用户交互的HTML文件。它代表了用户的模型数据。

控制器(Controller)

它充当视图和模型之间的中介。它侦听由视图(View)和查询模型触发的事件。

Python代码

下面通过一个名为“Person”的基本对象并创建一个MVC设计模式。

文件:Model.py -

import json

class Person(object):
def __init__(self, first_name = None, last_name = None):
self.first_name = first_name
self.last_name = last_name
#returns Person name, ex: John Doe
def name(self):
return ("%s %s" % (self.first_name,self.last_name))

@classmethod
#returns all people inside db.txt as list of Person objects
def getAll(self):
database = open('db.txt', 'r')
result = []
json_list = json.loads(database.read())
for item in json_list:
item = json.loads(item)
person = Person(item['first_name'], item['last_name'])
result.append(person)
return result

它需要一个方法来获取数据库中Person表的所有记录。记录以JSON格式显示。

视图

它显示模型中获取的所有记录。视图从不与模型交互; 由控制器完成这项工作(与模型和视图进行通信)。

from model import Person
def showAllView(list):
print 'In our db we have %i users. Here they are:' % len(list)
for item in list:
print item.name()
def startView():
print 'MVC - the simplest example'
print 'Do you want to see everyone in my db?[y/n]'
def endView():
print 'Goodbye!'

控制器

控制器通过getAll()方法与模型交互，getAll()方法获取显示给最终用户的所有记录。

from model import Person
import view

def showAll():
#gets list of all Person objects
people_in_db = Person.getAll()
#calls view
return view.showAllView(people_in_db)

def start():
view.startView()
input = raw_input()
if input == 'y':
return showAll()
else:
return view.endView()

if __name__ == "__main__":
#running controller function
start()

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

单例模式 - Python设计模式™

单例模式将类的实例化限制为一个对象。它是一种创建模式，只涉及创建方法和指定对象的一个类。

它提供了创建实例的全局访问点。

如何实现一个单例类？

下面的程序演示了单例类的实现，并多次打印创建的实例。

class Singleton:
__instance = None
@staticmethod
def getInstance():
""" Static access method. """
if Singleton.__instance == None:
Singleton()
return Singleton.__instance
def __init__(self):
""" Virtually private constructor. """
if Singleton.__instance != None:
raise Exception("This class is a singleton!")
else:
Singleton.__instance = self
s = Singleton()
print s

s = Singleton.getInstance()
print s

s = Singleton.getInstance()
print s

执行上面的程序后，生成以下输出 -

创建的实例数量相同，并且打印的对象是同一个对象。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

工厂模式 - Python设计模式™

工厂模式属于创建模式列表类别。它提供了创建对象的最佳方法。在工厂模式中，创建对象时不会将逻辑公开给客户端，并使用通用接口引用新创建的对象。

工厂模式使用工厂方法在Python中实现。当用户调用一个方法时，传入一个字符串，并通过工厂方法实现创建一个新对象，并将此对象作为返回值。工厂方法中使用的对象类型由通过方法传递的字符串确定。

在下面的例子中，每个方法都包含对象作为参数，这是通过工厂方法实现的。

如何实施工厂模式？

现在让我们看看如何实现工厂模式。参考以下代码 -

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

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

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

class Flash(Button):
html = "<obj></obj>"

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

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

Button类有助于创建html标签和关联的html页面。客户端将无法访问代码的逻辑，只输出表示创建html页面。

执行上面示例代码，得到以下结果 -

说明:python代码包含html标签的逻辑，这是指定的值。最终用户可以查看由Python代码创建的HTML文件。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

构建器(Builder)设计模式 - Python设计模式™

构建器(Builder)模式是一种独特的设计模式，它有助于使用简单对象构建复杂对象并使用算法。这种设计模式属于创建型模式。在这种设计模式中，构建器类逐步构建最终对象。该构建器独立于其他对象。

构建器(Builder)模式的优点

它提供了清晰的分离和独特的层次，可以在构建和表示由类创建的指定对象之间进行表示。
它可以更好地控制所建模式的实现过程。
它提供了改变对象内部表示的场景。

如何实现构建器模式？

在本节中，我们将学习如何实现构建器模式。参考以下实现代码 -

class Director:
__builder = None

def setBuilder(self, builder):
self.__builder = builder

def getCar(self):
car = Car()

# First goes the body
body = self.__builder.getBody()
car.setBody(body)

# Then engine
engine = self.__builder.getEngine()
car.setEngine(engine)

# And four wheels
i = 0
while i < 4:
wheel = self.__builder.getWheel()
car.attachWheel(wheel)
i += 1
return car

# The whole product
class Car:
def __init__(self):
self.__wheels = list()
self.__engine = None
self.__body = None

def setBody(self, body):
self.__body = body

def attachWheel(self, wheel):
self.__wheels.append(wheel)

def setEngine(self, engine):
self.__engine = engine

def specification(self):
print "body: %s" % self.__body.shape
print "engine horsepower: %d" % self.__engine.horsepower
print "tire size: %d\'" % self.__wheels[0].size

class Builder:
def getWheel(self): pass
def getEngine(self): pass
def getBody(self): pass

class JeepBuilder(Builder):

def getWheel(self):
wheel = Wheel()
wheel.size = 22
return wheel

def getEngine(self):
engine = Engine()
engine.horsepower = 400
return engine

def getBody(self):
body = Body()
body.shape = "SUV"
return body

# Car parts
class Wheel:
size = None

class Engine:
horsepower = None

class Body:
shape = None

def main():
jeepBuilder = JeepBuilder() # initializing the class

director = Director()

# Build Jeep
print "Jeep"
director.setBuilder(jeepBuilder)
jeep = director.getCar()
jeep.specification()
print ""

if __name__ == "__main__":
main()

执行上面程序，得到以下输出结果 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

原型设计模式 - Python设计模式™

原型设计模式有助于隐藏该类创建实例的复杂性，在对象的概念将与从头创建的新对象的概念不同。

如果需要，新复制的对象可能会在属性中进行一些更改。这种方法节省了开发产品的时间和资源。

如何实现原型模式？

现在让我们看看如何实现原型模式。代码实现如下 -

import copy

class Prototype:

_type = None
_value = None

def clone(self):
pass

def getType(self):
return self._type

def getValue(self):
return self._value

class Type1(Prototype):

def __init__(self, number):
self._type = "Type1"
self._value = number

def clone(self):
return copy.copy(self)

class Type2(Prototype):

""" Concrete prototype. """

def __init__(self, number):
self._type = "Type2"
self._value = number

def clone(self):
return copy.copy(self)

class ObjectFactory:

""" Manages prototypes.
Static factory, that encapsulates prototype
initialization and then allows instatiation
of the classes from these prototypes.
"""

__type1Value1 = None
__type1Value2 = None
__type2Value1 = None
__type2Value2 = None

@staticmethod
def initialize():
ObjectFactory.__type1Value1 = Type1(1)
ObjectFactory.__type1Value2 = Type1(2)
ObjectFactory.__type2Value1 = Type2(1)
ObjectFactory.__type2Value2 = Type2(2)

@staticmethod
def getType1Value1():
return ObjectFactory.__type1Value1.clone()

@staticmethod
def getType1Value2():
return ObjectFactory.__type1Value2.clone()

@staticmethod
def getType2Value1():
return ObjectFactory.__type2Value1.clone()

@staticmethod
def getType2Value2():
return ObjectFactory.__type2Value2.clone()

def main():
ObjectFactory.initialize()

instance = ObjectFactory.getType1Value1()
print "%s: %s" % (instance.getType(), instance.getValue())

instance = ObjectFactory.getType1Value2()
print "%s: %s" % (instance.getType(), instance.getValue())

instance = ObjectFactory.getType2Value1()
print "%s: %s" % (instance.getType(), instance.getValue())

instance = ObjectFactory.getType2Value2()
print "%s: %s" % (instance.getType(), instance.getValue())

if __name__ == "__main__":
main()

执行上面程序，将生成以下输出 -

输出中，使用现有的对象创建新对象，并且在上述输出中清晰可见。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

门面(Facade)设计模式 - Python设计模式™

门面(Facade)设计模式为子系统中的一组接口提供统一的接口。它定义了任何子系统都可以使用的更高级别的接口。

一个门面(Facade)类知道哪个子系统负责请求。

如何设计门面(Facade)模式？

现在让我们看看如何设计一个门面(Facade)设计模式。参考以下实现代码 -

class _IgnitionSystem(object):

@staticmethod
def produce_spark():
return True

class _Engine(object):

def __init__(self):
self.revs_per_minute = 0

def turnon(self):
self.revs_per_minute = 2000

def turnoff(self):
self.revs_per_minute = 0

class _FuelTank(object):

def __init__(self, level=30):
self._level = level

@property
def level(self):
return self._level

@level.setter
def level(self, level):
self._level = level

class _DashBoardLight(object):

def __init__(self, is_on=False):
self._is_on = is_on

def __str__(self):
return self.__class__.__name__

@property
def is_on(self):
return self._is_on

@is_on.setter
def is_on(self, status):
self._is_on = status

def status_check(self):
if self._is_on:
print("{}: ON".format(str(self)))
else:
print("{}: OFF".format(str(self)))

class _HandBrakeLight(_DashBoardLight):
pass

class _FogLampLight(_DashBoardLight):
pass

class _Dashboard(object):

def __init__(self):
self.lights = {"handbreak": _HandBrakeLight(), "fog": _FogLampLight()}

def show(self):
for light in self.lights.values():
light.status_check()

# Facade
class Car(object):

def __init__(self):
self.ignition_system = _IgnitionSystem()
self.engine = _Engine()
self.fuel_tank = _FuelTank()
self.dashboard = _Dashboard()

@property
def km_per_litre(self):
return 17.0

def consume_fuel(self, km):
litres = min(self.fuel_tank.level, km / self.km_per_litre)
self.fuel_tank.level -= litres

def start(self):
print("\nStarting...")
self.dashboard.show()
if self.ignition_system.produce_spark():
self.engine.turnon()
else:
print("Can't start. Faulty ignition system")

def has_enough_fuel(self, km, km_per_litre):
litres_needed = km / km_per_litre
if self.fuel_tank.level > litres_needed:
return True
else:
return False

def drive(self, km = 100):
print("\n")
if self.engine.revs_per_minute > 0:
while self.has_enough_fuel(km, self.km_per_litre):
self.consume_fuel(km)
print("Drove {}km".format(km))
print("{:.2f}l of fuel still left".format(self.fuel_tank.level))
else:
print("Can't drive. The Engine is turned off!")

def park(self):
print("\nParking...")
self.dashboard.lights["handbreak"].is_on = True
self.dashboard.show()
self.engine.turnoff()

def switch_fog_lights(self, status):
print("\nSwitching {} fog lights...".format(status))
boolean = True if status == "ON" else False
self.dashboard.lights["fog"].is_on = boolean
self.dashboard.show()

def fill_up_tank(self):
print("\nFuel tank filled up!")
self.fuel_tank.level = 100

# the main function is the Client
def main():
car = Car()
car.start()
car.drive()
car.switch_fog_lights("ON")
car.switch_fog_lights("OFF")
car.park()
car.fill_up_tank()
car.drive()
car.start()
car.drive()

if __name__ == "__main__":
main()

执行上面程序，生成以下输出 -

注意:这个程序是设计一个场景。这是启动汽车或任何车辆的发动机。如果您观察代码，它还包括驱动，停车和消耗燃料的相关功能。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

命令设计模式 - Python设计模式™

命令模式在动作之间添加一个抽象级别，并包含一个调用这些动作的对象。

在这种设计模式中，客户端创建一个包含要执行的命令列表的命令对象。创建的命令对象实现了特定的接口。

以下是命令模式的基本架构 -

如何实现命令模式？

现在我们将看到如何实现设计模式。参考以下实现代码 -

def demo(a,b,c):
print 'a:',a
print 'b:',b
print 'c:',c

class Command:
def __init__(self, cmd, *args):
self._cmd=cmd
self._args=args

def __call__(self, *args):
return apply(self._cmd, self._args+args)
cmd = Command(dir,__builtins__)
print cmd()

cmd = Command(demo,1,2)
cmd(3)

执行上述程序生成以下输出 -

注意:输出实现了Python语言中列出的所有命令和关键字。它打印变量的值。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

适配器设计模式 - Python设计模式™

适配器模式可用作两个不兼容接口之间的桥梁。这种类型的设计模式属于结构模式，因为此模式结合了两个独立接口的功能。

这种模式涉及一个类，它负责连接独立或不兼容接口的功能。一个现实的例子是读卡器，它是存储卡和笔记本电脑之间的适配器。您将存储卡插入读卡器，将读卡器插入笔记本电脑，以便通过笔记本电脑读取存储卡。

适配器设计模式有助于类能在一起工作。它根据需求将一个类的接口转换为另一个接口。该模式包括一个多态性，它命名一个名称和多个形式。根据收集到的要求，生成一个使用的形状类。

适配器模式有两种类型 -

对象适配器模式 - 这种设计模式依赖于对象实现。因此，它被称为对象适配器模式。
类适配器模式 - 这是实现适配器设计模式的另一种方式。该模式可以使用多重继承来实现。

如何实现适配器模式？

现在让我们看看如何实现适配器模式。参考以下代码 -

class EuropeanSocketInterface:
def voltage(self): pass

def live(self): pass
def neutral(self): pass
def earth(self): pass

# Adaptee
class Socket(EuropeanSocketInterface):
def voltage(self):
return 230

def live(self):
return 1

def neutral(self):
return -1

def earth(self):
return 0

# Target interface
class USASocketInterface:
def voltage(self): pass
def live(self): pass
def neutral(self): pass

# The Adapter
class Adapter(USASocketInterface):
__socket = None
def __init__(self, socket):
self.__socket = socket

def voltage(self):
return 110

def live(self):
return self.__socket.live()

def neutral(self):
return self.__socket.neutral()

# Client
class ElectricKettle:
__power = None

def __init__(self, power):
self.__power = power

def boil(self):
if self.__power.voltage() > 110:
print "Kettle on fire!"
else:
if self.__power.live() == 1 and \
self.__power.neutral() == -1:
print "Coffee time!"
else:
print "No power."

def main():
# Plug in
socket = Socket()
adapter = Adapter(socket)
kettle = ElectricKettle(adapter)

# Make coffee
kettle.boil()

return 0

if __name__ == "__main__":
main()

执行上面示例代码，得到以上结果 -

说明:代码包括具有各种参数和属性的适配器接口。它包括Adaptee和Target接口，它实现所有属性并将输出显示为可见。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

装饰器设计模式 - Python设计模式™

装饰器模式允许用户在不改变其结构的情况下向现有对象添加新功能。这种类型的设计模式属于结构模式，因为此模式充当现有类的包装。

这个模式创建了一个装饰器类，它封装了原始类，并提供了额外的功能，保持了类方法签名的完整性。

装饰者模式的动机是动态地附加对象的额外职责(功能)。

　如何实现装饰设计模式?

下面提到的代码是如何在Python中实现装饰器设计模式的简单演示。该示例涉及以类形式展示咖啡店(coffeeshop类)。创建的 coffee 类是一个抽象类，这意味着它不能被实例化。

import six
from abc import ABCMeta

@six.add_metaclass(ABCMeta)
class Abstract_Coffee(object):

def get_cost(self):
pass

def get_ingredients(self):
pass

def get_tax(self):
return 0.1*self.get_cost()

class Concrete_Coffee(Abstract_Coffee):

def get_cost(self):
return 1.00

def get_ingredients(self):
return 'coffee'

@six.add_metaclass(ABCMeta)
class Abstract_Coffee_Decorator(Abstract_Coffee):

def __init__(self,decorated_coffee):
self.decorated_coffee = decorated_coffee

def get_cost(self):
return self.decorated_coffee.get_cost()

def get_ingredients(self):
return self.decorated_coffee.get_ingredients()

class Sugar(Abstract_Coffee_Decorator):

def __init__(self,decorated_coffee):
Abstract_Coffee_Decorator.__init__(self,decorated_coffee)

def get_cost(self):
return self.decorated_coffee.get_cost()

def get_ingredients(self):
return self.decorated_coffee.get_ingredients() + ', sugar'

class Milk(Abstract_Coffee_Decorator):

def __init__(self,decorated_coffee):
Abstract_Coffee_Decorator.__init__(self,decorated_coffee)

def get_cost(self):
return self.decorated_coffee.get_cost() + 0.25

def get_ingredients(self):
return self.decorated_coffee.get_ingredients() + ', milk'

class Vanilla(Abstract_Coffee_Decorator):

def __init__(self,decorated_coffee):
Abstract_Coffee_Decorator.__init__(self,decorated_coffee)

def get_cost(self):
return self.decorated_coffee.get_cost() + 0.75

def get_ingredients(self):
return self.decorated_coffee.get_ingredients() + ', vanilla'

如下所述，coffeeshop抽象类的实现是通过一个单独的文件完成的 -

import coffeeshop

myCoffee = coffeeshop.Concrete_Coffee()
print('Ingredients: '+myCoffee.get_ingredients()+
'; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Milk(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
'; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Vanilla(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
'; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Sugar(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
'; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

执行上述程序生成以下输出 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

代理设计模式 - Python设计模式™

代理设计模式包含一个新对象，称为“代理”，代替被称为“真实主体”的现有对象。由真实主体创建的代理对象必须位于相同的接口上，以便不让客户端知道使用代理来代替真实对象。客户端向代理生成的请求将通过真实主体传递。

代理模式的UML表示如下 -

如何实现代理模式？

现在让我们来看看如何实现代理模式。参考以下实现代码 -

class Image:
def __init__( self, filename ):
self._filename = filename

def load_image_from_disk( self ):
print("loading " + self._filename )

def display_image( self ):
print("display " + self._filename)

class Proxy:
def __init__( self, subject ):
self._subject = subject
self._proxystate = None

class ProxyImage( Proxy ):
def display_image( self ):
if self._proxystate == None:
self._subject.load_image_from_disk()
self._proxystate = 1
print("display " + self._subject._filename )

proxy_image1 = ProxyImage ( Image("HiRes_10Mb_Photo1") )
proxy_image2 = ProxyImage ( Image("HiRes_10Mb_Photo2") )

proxy_image1.display_image() # loading necessary
proxy_image1.display_image() # loading unnecessary
proxy_image2.display_image() # loading necessary
proxy_image2.display_image() # loading unnecessary
proxy_image1.display_image() # loading unnecessary

执行上述程序生成以下输出 -

代理模式设计有助于复制创建的图像。 display_image()函数有助于检查值是否在命令提示符下打印。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

责任链设计模式 - Python设计模式™

责任链模式用于实现软件中的松散耦合，其中来自客户端的指定请求通过包含在其中的对象链传递。它有助于构建一系列对象。请求从一端进入并从一个对象移动到另一个对象。

该模式允许对象发送命令而不知道哪个对象将处理该请求。

如何实现责任链模式？

现在我们将看到如何实施责任链模式。参考以下实现代码 -

class ReportFormat(object):
PDF = 0
TEXT = 1
class Report(object):
def __init__(self, format_):
self.title = 'Monthly report'
self.text = ['Things are going', 'really, really well.']
self.format_ = format_

class Handler(object):
def __init__(self):
self.nextHandler = None

def handle(self, request):
self.nextHandler.handle(request)

class PDFHandler(Handler):

def handle(self, request):
if request.format_ == ReportFormat.PDF:
self.output_report(request.title, request.text)
else:
super(PDFHandler, self).handle(request)

def output_report(self, title, text):
print '<html>'
print ' <head>'
print ' <title>%s</title>' % title
print ' </head>'
print ' <body>'
for line in text:
print ' <p>%s
' % line
print ' </body>'
print '</html>'

class TextHandler(Handler):

def handle(self, request):
if request.format_ == ReportFormat.TEXT:
self.output_report(request.title, request.text)
else:
super(TextHandler, self).handle(request)

def output_report(self, title, text):
print 5*'*' + title + 5*'*'
for line in text:
print line

class ErrorHandler(Handler):
def handle(self, request):
print "Invalid request"

if __name__ == '__main__':
report = Report(ReportFormat.TEXT)
pdf_handler = PDFHandler()
text_handler = TextHandler()

pdf_handler.nextHandler = text_handler
text_handler.nextHandler = ErrorHandler()
pdf_handler.handle(report)

执行上述程序生成以下输出 -

解释说明

上面的代码是创建一个报告的月任务，通过每个函数发送命令。它需要两个处理程序 - 用于PDF和文本。当所需的对象执行每个功能，它将打印输出。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

观察者设计模式 - Python设计模式™

在观察者设计模式这种模式中，对象被表示为等待事件触发的观察者。一旦发生指定的事件，观察者就会关注该主体。当事件发生时，主体告诉观察者它已经发生。

以下UML图表示观察者模式 -

如何实现观察者模式？

现在让我们来看看如何实现观察者模式。参考以下实现代码 -

import threading
import time
import pdb

class Downloader(threading.Thread):

def run(self):
print 'downloading'
for i in range(1,5):
self.i = i
time.sleep(2)
print 'unfunf'
return 'hello world'

class Worker(threading.Thread):
def run(self):
for i in range(1,5):
print 'worker running: %i (%i)' % (i, t.i)
time.sleep(1)
t.join()

print 'done'

t = Downloader()
t.start()

time.sleep(1)

t1 = Worker()
t1.start()

t2 = Worker()
t2.start()

t3 = Worker()
t3.start()

执行上述程序生成以下输出 -

解释说明

上面的代码解释了下载特定结果的过程。根据观察者模式逻辑，每个对象都被视为观察者。它在事件触发时打印输出。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

状态设计模式 - Python设计模式™

它为状态机提供了一个模块，它使用从指定的状态机类派生而来的子类来实现。这些方法独立于状态，并使用装饰器声明转换。

如何实现状态模式？

状态模式的基本实现，请参考如下代码 -

class ComputerState(object):

name = "state"
allowed = []

def switch(self, state):
""" Switch to new state """
if state.name in self.allowed:
print 'Current:',self,' => switched to new state',state.name
self.__class__ = state
else:
print 'Current:',self,' => switching to',state.name,'not possible.'

def __str__(self):
return self.name

class Off(ComputerState):
name = "off"
allowed = ['on']

class On(ComputerState):
""" State of being powered on and working """
name = "on"
allowed = ['off','suspend','hibernate']

class Suspend(ComputerState):
""" State of being in suspended mode after switched on """
name = "suspend"
allowed = ['on']

class Hibernate(ComputerState):
""" State of being in hibernation after powered on """
name = "hibernate"
allowed = ['on']

class Computer(object):
""" A class representing a computer """

def __init__(self, model='HP'):
self.model = model
# State of the computer - default is off.
self.state = Off()

def change(self, state):
""" Change state """
self.state.switch(state)

if __name__ == "__main__":
comp = Computer()
comp.change(On)
comp.change(Off)
comp.change(On)
comp.change(Suspend)
comp.change(Hibernate)
comp.change(On)
comp.change(Off)

执行上述程序生成以下输出 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

策略设计模式 - Python设计模式™

策略模式是一种行为模式。策略模式的主要目标是使客户能够从不同的算法或程序中进行选择以完成指定的任务。不同的算法可以交换出入，而不会对上述任务产生任何影响。

当访问外部资源时，可以使用此模式来提高灵活性。

如何实施策略模式？

有关如何使用Python实现策略模式，请参考以下代码 -

import types

class StrategyExample:
def __init__(self, func = None):
self.name = 'Strategy Example 0'
if func is not None:
self.execute = types.MethodType(func, self)

def execute(self):
print(self.name)

def execute_replacement1(self):
print(self.name + 'from execute 1')

def execute_replacement2(self):
print(self.name + 'from execute 2')

if __name__ == '__main__':
strat0 = StrategyExample()
strat1 = StrategyExample(execute_replacement1)
strat1.name = 'Strategy Example 1'
strat2 = StrategyExample(execute_replacement2)
strat2.name = 'Strategy Example 2'
strat0.execute()
strat1.execute()
strat2.execute()

执行上述程序生成以下输出 -

解释说明

它提供执行输出的函数的策略列表。这种行为模式的主要焦点是行为。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

模板设计模式 - Python设计模式™

模板模式使用抽象操作在基类中定义基本算法，其中子类覆盖具体行为。模板模式将算法的轮廓保留在单独的方法中。该方法被称为模板方法。

以下是模板模式的不同功能 -

它定义了操作中算法的骨架。
它包括子类，它重新定义了算法的某些步骤。

有关模板设计模式的实现，请参考以下代码 -

class MakeMeal:

def prepare(self): pass
def cook(self): pass
def eat(self): pass

def go(self):
self.prepare()
self.cook()
self.eat()

class MakePizza(MakeMeal):
def prepare(self):
print "Prepare Pizza"

def cook(self):
print "Cook Pizza"

def eat(self):
print "Eat Pizza"

class MakeTea(MakeMeal):
def prepare(self):
print "Prepare Tea"

def cook(self):
print "Cook Tea"

def eat(self):
print "Eat Tea"

makePizza = MakePizza()
makePizza.go()

print 25*"+"

makeTea = MakeTea()
makeTea.go()

执行上面示例代码，得到以下结果 -

解释说明

此代码创建一个模板来准备餐点。在这里，参数表示用于创建茶，披萨等餐点的一部分的属性。输出表示属性的可视化。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

享元设计模式 - Python设计模式™

享元(flyweight)设计模式属于结构设计模式类别。它提供了一种减少对象数的方法。它包含各种有助于改进应用程序结构的功能。享元对象最重要的特性是不可变的。这意味着一旦构建就不能修改它们。该模式使用HashMap来存储引用对象。

如何实现享元(flyweight)设计模式？

以下程序演示如何实现享元模式 -

class ComplexGenetics(object):
def __init__(self):
pass

def genes(self, gene_code):
return "ComplexPatter[%s]TooHugeinSize" % (gene_code)
class Families(object):
family = {}

def __new__(cls, name, family_id):
try:
id = cls.family[family_id]
except KeyError:
id = object.__new__(cls)
cls.family[family_id] = id
return id

def set_genetic_info(self, genetic_info):
cg = ComplexGenetics()
self.genetic_info = cg.genes(genetic_info)

def get_genetic_info(self):
return (self.genetic_info)

def test():
data = (('a', 1, 'ATAG'), ('a', 2, 'AAGT'), ('b', 1, 'ATAG'))
family_objects = []
for i in data:
obj = Families(i[0], i[1])
obj.set_genetic_info(i[2])
family_objects.append(obj)

for i in family_objects:
print "id = " + str(id(i))
print i.get_genetic_info()
print "similar id's says that they are same objects "

if __name__ == '__main__':
test()

执行上述程序生成以下输出 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

抽象工厂设计模式 - Python设计模式™

抽象工厂模式也被称为工厂的工厂。此设计模式属于创建设计模式类别。它提供了创建对象的最佳方法之一。

它包含一个接口，负责创建与工厂相关的对象。

如何实现抽象工厂模式？

参考以下程序，演示如何实现抽象工厂模式。

class Window:
__toolkit = ""
__purpose = ""

def __init__(self, toolkit, purpose):
self.__toolkit = toolkit
self.__purpose = purpose

def getToolkit(self):
return self.__toolkit

def getType(self):
return self.__purpose

class GtkToolboxWindow(Window):
def __init__(self):
Window.__init__(self, "Gtk", "ToolboxWindow")

class GtkLayersWindow(Window):
def __init__(self):
Window.__init__(self, "Gtk", "LayersWindow")

class GtkMainWindow(Window):
def __init__(self):
Window.__init__(self, "Gtk", "MainWindow")

class QtToolboxWindow(Window):
def __init__(self):
Window.__init__(self, "Qt", "ToolboxWindow")

class QtLayersWindow(Window):
def __init__(self):
Window.__init__(self, "Qt", "LayersWindow")

class QtMainWindow(Window):
def __init__(self):
Window.__init__(self, "Qt", "MainWindow")

# Abstract factory class
class UIFactory:
def getToolboxWindow(self): pass
def getLayersWindow(self): pass
def getMainWindow(self): pass

class GtkUIFactory(UIFactory):
def getToolboxWindow(self):
return GtkToolboxWindow()
def getLayersWindow(self):
return GtkLayersWindow()
def getMainWindow(self):
return GtkMainWindow()

class QtUIFactory(UIFactory):
def getToolboxWindow(self):
return QtToolboxWindow()
def getLayersWindow(self):
return QtLayersWindow()
def getMainWindow(self):
return QtMainWindow()

if __name__ == "__main__":
gnome = True
kde = not gnome

if gnome:
ui = GtkUIFactory()
elif kde:
ui = QtUIFactory()

toolbox = ui.getToolboxWindow()
layers = ui.getLayersWindow()
main = ui.getMainWindow()

print "%s:%s" % (toolbox.getToolkit(), toolbox.getType())
print "%s:%s" % (layers.getToolkit(), layers.getType())
print "%s:%s" % (main.getToolkit(), main.getType())

执行上面示例代码，得到以下结果 -

说明
在上面的程序中，抽象工厂为每个窗口创建对象。它调用每个方法，按预期执行输出。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

面向对象设计模式 - Python设计模式™

面向对象的模式是最常用的模式。几乎所有的编程语言都可以找到这种模式。

如何实现面向对象的模式？

下面让我们看看如何实现面向对象的模式。参考以下实现代码 -

class Parrot:
# class attribute
species = "bird"

# instance attribute
def __init__(self, name, age):
self.name = name
self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

执行上面示例代码，得到以下输出结果 -

说明
代码包括类属性和实例属性，它们按照输出的要求打印。有各种功能构成面向对象模式的一部分。这些功能在下一章中介绍。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

面向对象概念的实现 - Python设计模式™

在本章中，我们将重点学习使用面向对象概念的模式及其在Python中的实现。当我们围绕函数设计围绕语句块的程序时，它被称为面向过程的编程。在面向对象编程中，有两个主要的实例叫做类和对象。

如何实现类和对象变量？

类和对象变量的实现如下 -

class Robot:
population = 0

def __init__(self, name):
self.name = name
print("(Initializing {})".format(self.name))
Robot.population += 1

def die(self):
print("{} is being destroyed!".format(self.name))
Robot.population -= 1
if Robot.population == 0:
print("{} was the last one.".format(self.name))
else:
print("There are still {:d} robots working.".format(
Robot.population))

def say_hi(self):
print("Greetings, my masters call me {}.".format(self.name))

@classmethod
def how_many(cls):
print("We have {:d} robots.".format(cls.population))
droid1 = Robot("R2-D2")
droid1.say_hi()
Robot.how_many()

droid2 = Robot("C-3PO")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")

print("Robots have finished their work. So let's destroy them.")
droid1.die()
droid2.die()

Robot.how_many()

执行上述程序生成以下输出 -

说明
此图有助于展示类和对象变量的性质。

“population”属于“Robot”类。因此，它被称为类变量或对象。
在这里，将population类变量称为Robot.population，而不是self.population。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

迭代器设计模式 - Python设计模式™

迭代器设计模式属于行为设计模式类别。开发人员几乎在每种编程语言中都遇到了迭代器模式。这种模式的使用方式有助于以顺序方式访问集合(类)的元素，而无需了解底层设计。

如何实现迭代器模式？

下面我们来看看如何实现迭代器模式。参考以下设计代码 -

import time

def fib():
a, b = 0, 1
while True:
yield b
a, b = b, a + b

g = fib()

try:
for e in g:
print(e)
time.sleep(1)

except KeyboardInterrupt:
print("Calculation stopped")

执行上述程序生成以下输出 -

如果使用这个模式，则使用迭代器模式打印斐波那契数列。强制终止用户时，打印以下输出 -

说明

这个Python代码遵循迭代器模式。这里，增量操作符用于开始计数。计数结束于用户强行终止。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

字典实现 - Python设计模式™

字典是数据结构，其中包含关键值组合。这些被广泛用于代替JSON - JavaScript Object Notation。字典用于API(应用程序编程接口)编程。字典将一组对象映射到另一组对象。字典是可变的; 这意味着它们可以根据需要根据需要进行更改。

如何在Python中实现字典？

下面的程序展示了从Python创建到Python中字典的基本实现。

# Create a new dictionary
d = dict() # or d = {}

# Add a key - value pairs to dictionary
d['xyz'] = 123
d['abc'] = 345

# print the whole dictionary
print(d)

# print only the keys
print(d.keys())

# print only values
print(d.values())

# iterate over dictionary
for i in d :
print("%s %d" %(i, d[i]))

# another method of iteration
for index, value in enumerate(d):
print (index, value , d[value])

# check if key exist 23. Python Data Structure –print('xyz' in d)

# delete the key-value pair
del d['xyz']

# check again
print("xyz" in d)

执行上面示例代码，得到以下结果 -

注 - 在Python中执行字典有缺陷。

缺陷
字典不支持字符串，元组和列表等序列数据类型的序列操作。这些属于内置的映射类型。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

列表数据结构 - Python设计模式™

列表数据结构是Python中的一种多用途数据类型，可以将其编写为方括号之间的逗号分隔值列表。

语法

下面是结构的基本语法 -

list_name = [ element_1,element_2,...,element_n ];

如果您注意到，语法与数组一样声明，唯一的区别是列表可以包含具有不同数据类型的元素。这些数组包含相同数据类型的元素。列表可以包含字符串，整数和对象的组合。列表可以用于实现堆栈和队列。

列表是可变的，它可以根据需要进行更改。

如何实现列表？

以下程序显示了列表的实现 -

my_list = ['p','r','o','b','e']
# Output: p
print(my_list[0])

# Output: o
print(my_list[2])

# Output: e
print(my_list[4])

# Error! Only integer can be used for indexing
# my_list[4.0]

# Nested List
n_list = ["Happy", [2,0,1,5]]

# Nested indexing

# Output: a
print(n_list[0][1])

# Output: 5
print(n_list[1][3])

执行上述程序生成以下输出 -

Python列表的内置函数如下所示 -

append() - 它将元素添加到列表的末尾。
extend() - 它将列表的元素添加到另一个列表中。
insert() - 它将一个项目插入定义的索引。
remove() - 删除列表中指定的元素。
reverse() - 它倒置列表中的元素。
sort() - 它有助于按时间顺序对元素进行排序。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

集合 - Python设计模式™

一个集合可以被定义为无序的集合，它是可迭代的，可变的，并且其中不包含重复的元素。在Python中，set类是数学集的一种表示法。使用集合的主要优点是它包含用于检查特定元素的高度优化的方法。

Python包含一个独立的类别，称为冻结集。这些集合是不可变的对象，只支持产生所需结果的方法和运算符。

如何实现集合？

以下程序演示如何实现集合 -

# Set in Python

# Creating two sets
set1 = set()
set2 = set()

# Adding elements to set1
for i in range(1, 6):
set1.add(i)

# Adding elements to set2
for i in range(3, 8):
set2.add(i)

print("Set1 = ", set1)
print("Set2 = ", set2)
print("\n")

# Union of set1 and set2
set3 = set1 | set2# set1.union(set2)
print("Union of Set1 & Set2: Set3 = ", set3)

# Intersection of set1 and set2
set4 = set1 & set2# set1.intersection(set2)
print("Intersection of Set1 & Set2: Set4 = ", set4)
print("\n")

# Checking relation between set3 and set4
if set3 > set4: # set3.issuperset(set4)
print("Set3 is superset of Set4")
elif set3 < set4: # set3.issubset(set4)
print("Set3 is subset of Set4")
else : # set3 == set4
print("Set3 is same as Set4")

# displaying relation between set4 and set3
if set4 < set3: # set4.issubset(set3)
print("Set4 is subset of Set3")
print("\n")

# difference between set3 and set4
set5 = set3 - set4
print("Elements in Set3 and not in Set4: Set5 = ", set5)
print("\n")

# checkv if set4 and set5 are disjoint sets
if set4.isdisjoint(set5):
print("Set4 and Set5 have nothing in common\n")

# Removing all the values of set5
set5.clear()

print("After applying clear on sets Set5: ")
print("Set5 = ", set5)

执行上面示例代码，得到以下结果 -

以下程序演示冻结集合的使用 -

normal_set = set(["a", "b","c"])

# Adding an element to normal set is fine
normal_set.add("d")

print("Normal Set")
print(normal_set)

# A frozen set
frozen_set = frozenset(["e", "f", "g"])

print("Frozen Set")
print(frozen_set)

执行上面示例代码，得到以下结果 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

队列 - Python设计模式™

队列是对象的集合，它定义了FIFO(先进先出)和LIFO(后进先出)过程之后的简单数据结构。插入和删除操作被称为入队和出队操作。

队列不允许随机访问它们包含的对象。

如何实现FIFO程序？

以下程序演示如何实现先进先出(FIFO) -

import Queue

q = Queue.Queue()

#put items at the end of the queue
for x in range(4):
q.put("item-" + str(x))

#remove items from the head of the queue
while not q.empty():
print q.get()

执行上述程序生成以下输出 -

如何实施LIFO程序？

以下程序如何实现LIFO程序 -

import Queue

q = Queue.LifoQueue()

#add items at the head of the queue
for x in range(4):
q.put("item-" + str(x))

#remove items from the head of the queue
while not q.empty():
print q.get()

执行上述程序生成以下输出 -

什么是优先级队列？

优先级队列是一个容器数据结构，它使用有序键管理一组记录，以提供对指定数据结构中具有最小或最大键的记录的快速访问。

如何实现优先队列？

优先队列的实现如下 -

import Queue

class Task(object):
def __init__(self, priority, name):
self.priority = priority
self.name = name

def __cmp__(self, other):
return cmp(self.priority, other.priority)

q = Queue.PriorityQueue()

q.put( Task(100, 'a not agent task') )
q.put( Task(5, 'a highly agent task') )
q.put( Task(10, 'an important task') )

while not q.empty():
cur_task = q.get()
print 'process task:', cur_task.name

执行上述程序生成以下输出 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

字符串和序列化 - Python设计模式™

字符串序列化是将对象状态写入字节流的过程。在python中，pickle库用于启用序列化。该模块包含一个用于序列化和反序列化Python对象结构的强大算法。 “Pickling”是将Python对象层次转换为字节流的过程，“unpickling”是相反的过程。

pickle模块的示列如下 -

import pickle

#Here's an example dict
grades = { 'Alice': 89, 'Bob': 72, 'Charles': 87 }

#Use dumps to convert the object to a serialized string
serial_grades = pickle.dumps( grades )
print(serial_grades)

#Use loads to de-serialize an object
received_grades = pickle.loads( serial_grades )
print(received_grades)

执行上面示例代码，得到以下结果 -

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

Python并发(多线程) - Python设计模式™

并发性常常被误解为并行性。并发意味着调度独立代码以系统方式执行。本章重点介绍使用Python的操作系统的并发执行。

以下程序实现执行操作系统的并发性 -

import os
import time
import threading
import multiprocessing

NUM_WORKERS = 4

def only_sleep():
print("PID: %s, Process Name: %s, Thread Name: %s" % (
os.getpid(),
multiprocessing.current_process().name,
threading.current_thread().name)
)
time.sleep(1)

def crunch_numbers():
print("PID: %s, Process Name: %s, Thread Name: %s" % (
os.getpid(),
multiprocessing.current_process().name,
threading.current_thread().name)
)
x = 0
while x < 10000000:
x += 1
for _ in range(NUM_WORKERS):
only_sleep()
end_time = time.time()
print("Serial time=", end_time - start_time)

# Run tasks using threads
start_time = time.time()
threads = [threading.Thread(target=only_sleep) for _ in range(NUM_WORKERS)]
[thread.start() for thread in threads]
[thread.join() for thread in threads]
end_time = time.time()

print("Threads time=", end_time - start_time)

# Run tasks using processes
start_time = time.time()
processes = [multiprocessing.Process(target=only_sleep()) for _ in range(NUM_WORKERS)]
[process.start() for process in processes]
[process.join() for process in processes]
end_time = time.time()

print("Parallel time=", end_time - start_time)

执行上述程序生成以下输出 -

说明
multiprocessing是一个类似于线程模块的包。该软件包支持本地和远程并发。由于这个模块，程序员可以在给定的系统上使用多个进程。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

反模式 - Python设计模式™

反模式遵循与预定义的设计模式相反的策略。该策略包含共同问题的常见方法，可以将其形式化，并且可以被普遍视为一种良好的开发实践。通常情况下，反模式是相反的并且是不可取的。反模式是软件开发中使用的某些模式，被认为是不好的编程实践。

反模式的重要特征

现在我们来看看反模式的一些重要特征。

正确性

这些模式从字面上破坏代码，并让你做错事。以下是对此的简单说明 -

class Rectangle(object):
def __init__(self, width, height):
self._width = width
self._height = height
r = Rectangle(5, 6)
# direct access of protected member
print("Width: {:d}".format(r._width))

可维护性

如果程序易于理解和根据要求进行修改，则称该程序是可维护的。导入模块可以被认为是可维护性的一个例子。

import math
x = math.ceil(y)
# or
import multiprocessing as mp
pool = mp.pool(8)

反模式示例

以下示例演示如何实现反模式 -

#Bad
def filter_for_foo(l):
r = [e for e in l if e.find("foo") != -1]
if not check_some_critical_condition(r):
return None
return r

res = filter_for_foo(["bar","foo","faz"])

if res is not None:
#continue processing
pass

#Good
def filter_for_foo(l):
r = [e for e in l if e.find("foo") != -1]
if not check_some_critical_condition(r):
raise SomeException("critical condition unmet!")
return r

try:
res = filter_for_foo(["bar","foo","faz"])
#continue processing

except SomeException:
i = 0
while i < 10:
do_something()
#we forget to increment i

说明
这个例子包括了在Python中创建函数的好的和坏的标准的演示。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

异常处理 - Python设计模式™

处理异常也是设计模式的主要标准。程序执行期间发生的错误是一个异常。发生特定错误时，生成异常很重要。这有助于遏制程序崩溃。

为什么使用异常？

异常是处理程序中的错误和特殊条件的便捷方式。当用户认为指定的代码可能产生错误时，使用异常处理很重要。

示例 - 除以零异常

import sys

randomList = ['a', 0, 2]

for entry in randomList:
try:
print("The entry is", entry)
r = 1/int(entry)
break
except:
print("Oops!",sys.exc_info()[0],"occured.")
print("Next entry.")
print()
print("The reciprocal of",entry,"is",r)

执行上面示例代码，得到以下结果 -

引发异常

特别是在Python编程中，当运行时出现相应的代码错误时会引发异常。这可以使用raise关键字强制引发。

语法

raise KeyboardInterrupt
Traceback (most recent call last):
...
KeyboardInterrupt

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」

关注作者

Tutorialspoint Python 设计模式教程

Tutorialspoint Python 设计模式教程

Python设计模式™

面向读者

前提条件

问题反馈

Python设计模式简介 - Python设计模式™

设计模式的结构

为什么使用Python？

Python设计模式概要 - Python设计模式™

Python语言的特点

要点

如何下载和安装python语言？

Python重要工具

构成Python的设计模式是什么？

模型视图控制器（MVC）模式 - Python设计模式™

单例模式 - Python设计模式™

如何实现一个单例类？

工厂模式 - Python设计模式™

如何实施工厂模式？

构建器(Builder)设计模式 - Python设计模式™

如何实现构建器模式？

原型设计模式 - Python设计模式™

如何实现原型模式？

门面(Facade)设计模式 - Python设计模式™

如何设计门面(Facade)模式？

命令设计模式 - Python设计模式™

如何实现命令模式？

适配器设计模式 - Python设计模式™

如何实现适配器模式？

装饰器设计模式 - Python设计模式™

如何实现装饰设计模式?

代理设计模式 - Python设计模式™

如何实现代理模式？

责任链设计模式 - Python设计模式™

如何实现责任链模式？

观察者设计模式 - Python设计模式™

如何实现观察者模式？

状态设计模式 - Python设计模式™

如何实现状态模式？

策略设计模式 - Python设计模式™

如何实施策略模式？

模板设计模式 - Python设计模式™

享元设计模式 - Python设计模式™

如何实现享元(flyweight)设计模式？

抽象工厂设计模式 - Python设计模式™

如何实现抽象工厂模式？

面向对象设计模式 - Python设计模式™

如何实现面向对象的模式？

面向对象概念的实现 - Python设计模式™

如何实现类和对象变量？

迭代器设计模式 - Python设计模式™

如何实现迭代器模式？

字典实现 - Python设计模式™

列表数据结构 - Python设计模式™

如何实现列表？

集合 - Python设计模式™

如何实现集合？

队列 - Python设计模式™

如何实现FIFO程序？

如何实施LIFO程序？

什么是优先级队列？

如何实现优先队列？

字符串和序列化 - Python设计模式™

Python并发(多线程) - Python设计模式™

反模式 - Python设计模式™

反模式的重要特征

异常处理 - Python设计模式™

为什么使用异常？

评论

　如何实现装饰设计模式?