1. WIKI教程
2. Python设计模式
3. 快速指南

快速指南

Python Design Patterns - Introduction

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

设计模式的结构

设计模式的文档以更加注重使用的技术和方式的方式进行维护。 下图说明了设计模式文档的基本结构。

图案名称

它以简短有效的方式描述了模式。

Intent/Motive

它描述了模式的作用。

适用性(Applicability)

它描述了模式适用的情况列表。

参与者和后果

参与者包括参与设计模式的类和对象，以及模式中存在的后果列表。

为何选择Python？

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

Python提供了对下面提到的设计模式列表的支持。 本教程将使用这些设计模式 -

• 模型视图控制器模式
• 单身人士模式
• 工厂模式
• 生成器模式
• 原型模式
• 门面模式
• 命令模式
• 适配器模式
• 原型模式
• Decorator Pattern
• 代理模式
• 责任链模式
• 观察者模式
• State Pattern
• 战略模式
• 模板模式
• Flyweight模式
• 抽象工厂模式
• 面向对象的模式

使用设计模式的好处

以下是设计模式的不同好处 -

• 模式为开发人员提供了针对指定问题的一系列久经考验的解决方案。

• 所有设计模式都是语言中立的。

• 模式有助于实现沟通和维护良好的文档。

• 它包括成就记录，以减少项目的任何技术风险。

• 设计模式使用起来非常灵活且易于理解。

Python Design Patterns - Gist

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

Python语言的特点

在本节中，我们将了解Python语言的不同功能。

Interpreted

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

Object-Oriented

Python遵循面向对象的样式和设计模式。 它包括具有各种功能的类定义，如封装，多态等等。

Portable

用Windows操作系统编写的Python代码，可以在Mac操作系统中使用。 代码可以根据要求重复使用和移植。

易于编码

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

可扩展(Extensible)

如果需要，用户也可以用C语言编写一些Python代码。 也可以将python代码放在​​不同语言（如C ++）的源代码中。 这使得Python成为一种可扩展的语言。

重点

考虑以下与Python编程语言相关的要点 -

• 它包括功能和结构化编程方法以及面向对象的编程方法。

• 它可以用作脚本语言或编程语言。

• 它包括自动垃圾收集。

• 它包括高级动态数据类型，并支持各种动态类型检查。

• Python包含与C，C ++和Java等语言集成的功能。

如何在您的系统中下载python语言？

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

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

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

Python中的重要工具

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

Python Strings

字符串的基本声明如下 -

str = 'Hello World!'

Python Lists

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

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

Python Tuples

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

tinytuple = (123, 'john')

Python Dictionary

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

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

什么构成了Python中的设计模式？

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

• 图案名称
• Intent
• Aliases
• Motivation
• Problem
• Solution
• Structure
• Participants
• Constraints
• 示例代码

Model View Controller Pattern

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

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

现在让我们看看结构是如何工作的。

模型 (Model)

它由纯应用程序逻辑组成，它与数据库交互。 它包括向最终用户表示数据的所有信息。

View

View表示与最终用户交互的HTML文件。 它向用户表示模型的数据。

控制器 (Controller)

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

Python code

让我们考虑一个名为“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格式显示。

View

它显示模型中提取的所有记录。 视图永远不会与模型交互; 控制器完成这项工作（与模型和视图进行通信）。

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!'

控制器 (Controller)

Controller通过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()

Python Design Patterns - Singleton

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

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

如何实现单例类？

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

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

输出 (Output)

上述程序生成以下输出 -

创建的实例数相同，输出中列出的对象没有区别。

Python Design Patterns - Factory

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

工厂模式使用工厂方法在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()

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

输出 (Output)

说明 (Explanation)

python代码包含html标记的逻辑，它指定了值。 最终用户可以查看Python代码创建的HTML文件。

Python Design Patterns - Builder

Builder Pattern是一种独特的设计模式，有助于使用简单对象构建复杂对象并使用算法方法。 这种设计模式属于创作模式的范畴。 在此设计模式中，构建器类按步骤构建最终对象。 此构建器独立于其他对象。

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()

输出 (Output)

上述程序生成以下输出 -

Python Design Patterns - Prototype

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

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

如何实现原型模式？

现在让我们看看如何实现原型模式。

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()

输出 (Output)

以上程序将生成以下输出 -

输出有助于使用现有对象创建新对象，并且在上面提到的输出中清晰可见。

Python Design Patterns - 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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

该程序设计了一个场景。 它是启动汽车或任何驾驶车辆的发动机。 如果你观察代码，它包括驱动，停放和消耗燃料的相关功能。

Python Design Patterns - Command

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

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

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

如何实现命令模式？

我们现在将看到如何实现设计模式。

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)

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Adapter

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

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

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

适配器模式有两种类型 -

对象适配器模式

此设计模式依赖于对象实现。 因此，它被称为对象适配器模式。

类适配器模式

这是实现适配器设计模式的另一种方法。 可以使用多个继承来实现该模式。

如何实现适配器模式？

现在让我们看看如何实现适配器模式。

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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Decorator

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

此模式创建一个装饰器类，它包装原始类并提供其他功能，使类方法签名保持不变。

装饰器模式的动机是动态附加对象的附加职责。

如何实现装饰设计模式

下面提到的代码是如何在Python中实现装饰器设计模式的简单演示。 插图包括以课堂形式演示咖啡店。 创建的咖啡类是抽象的，这意味着它无法实例化。

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'

咖啡店的抽象类的实现是使用下面提到的单独文件完成的 -

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()))

输出 (Output)

上述程序生成以下输出 -

Python Design Patterns - Proxy

代理设计模式包括一个新对象，称为“代理”代替现有对象，称为“真实主题”。 创建真实主题的代理对象必须位于同一个界面上，使客户端不应该知道代理被用来代替真实对象。 客户端向代理生成的请求将通过真实主题传递。

代理模式的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

输出 (Output)

上述程序生成以下输出 -

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

Chain of Responsibility

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

此模式允许对象在不知道哪个对象将处理请求的情况下发送命令。

如何实施责任链模式？

我们现在将看到如何实施责任链模式。

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<p></p>' % 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)

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Observer

在此模式中，对象表示为等待事件触发的观察者。 一旦指定事件发生，观察者就会附加到主题上。 当事件发生时，主体告诉观察者它已经发生。

以下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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - State

它为状态机提供了一个模块，该模块使用从指定的状态机类派生的子类实现。 这些方法与状态无关，并导致使用装饰器声明的转换。

如何实现状态模式？

状态模式的基本实现如下所示 -

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)

输出 (Output)

上述程序生成以下输出 -

Python Design Patterns - Strategy

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

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

如何实施战略模式？

下面显示的程序有助于实施战略模式。

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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Template

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

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

• 它定义了操作中算法的骨架

• 它包括子类，它重新定义了算法的某些步骤。

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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

此代码创建一个模板来准备膳食。 在这里，每个参数代表创建一部分餐点的属性，如茶，比萨饼等。

输出表示属性的可视化。

Python Design Patterns - Flyweight

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

如何实现flyweight模式？

以下程序有助于实现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()

输出 (Output)

上述程序生成以下输出 -

Python Design Patterns - Abstract Factory

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

它包括一个接口，负责创建与Factory相关的对象。

如何实现抽象工厂模式？

以下程序有助于实现抽象工厂模式。

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())

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Object Oriented

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

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

现在让我们看看如何实现面向对象的模式。

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))

输出 (Output)

上述程序生成以下输出

说明 (Explanation)

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

Object Oriented Concepts Implementation

在本章中，我们将重点介绍使用面向对象概念的模式及其在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()

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

此图有助于演示类和对象变量的本质。

• “人口”属于“机器人”类。 因此，它被称为类变量或对象。

• 在这里，我们将population类变量称为Robot.population而不是self.population。

Python Design Patterns - Iterator

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

如何实现迭代器模式？

我们现在将看到如何实现迭代器模式。

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")

输出 (Output)

上述程序生成以下输出 -

如果您专注于模式，Fibonacci系列将使用迭代器模式打印。 在强制终止用户时，将打印以下输出 -

说明 (Explanation)

这个python代码遵循迭代器模式。 这里，增量运算符用于开始计数。 计数在用户强制终止时结束。

Python Design Patterns - Dictionaries

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

如何在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)

输出 (Output)

上述程序生成以下输出 -

Note −在Python中实现字典有一些缺点。

缺点 (Drawback)

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

Lists Data Structure

列表数据结构是Python中的通用数据类型，可以写为方括号之间逗号分隔值的列表。

语法 (Syntax)

这是结构的基本语法 -

List_name = [ elements ];

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

列表是可变的。 这些可以在需要时更改。

如何实施清单？

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

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])

输出 (Output)

上述程序生成以下输出 -

Python列表的内置函数如下 -

• Append() - 它将元素添加到列表的末尾。

• Extend() - 它将列表的元素添加到另一个列表中。

• Insert() - 它将项目插入到定义的索引中。

• Remove() - 它从指定列表中删除元素。

• Reverse() - 它反转列表中的元素。

• sort() - 它有助于按时间顺序对元素进行排序。

Python Design Patterns - Sets

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

Python包含一个名为Frozen sets的单独类别。 这些集是不可变对象，仅支持产生所需结果的方法和运算符。

如何实现集合？

以下程序有助于实现集合 -

# 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)

输出 (Output)

上述程序生成以下输出 -

可以使用以下程序演示冷冻装置 -

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)

输出 (Output)

上述程序生成以下输出 -

Python Design Patterns - Queues

队列是一组对象，它们定义了FIFO（快速输入快速）和LIFO（后进先出）过程之后的简单数据结构。 插入和删除操作称为enqueue和dequeue操作。

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

如何实现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()

输出 (Output)

上述程序生成以下输出 -

如何实施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()

输出 (Output)

上述程序生成以下输出 -

什么是优先级队列？

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

如何实现优先级队列？

优先队列的实现如下 -

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

输出 (Output)

上述程序生成以下输出 -

Strings and Serialization

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

泡菜模块的演示如下 -

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)

输出 (Output)

上述程序生成以下输出 -

Concurrency in 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)

输出 (Output)

上述程序生成以下输出 -

说明 (Explanation)

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

Python Design Patterns - Anti

反模式遵循与预定义设计模式相对立的策略。 该战略包括共同问题的共同方法，这些方法可以正式化，并且通常可被视为良好的发展实践。 通常，反模式是相反的并且是不期望的。 反模式是软件开发中使用的某些模式，被认为是糟糕的编程实践。

反模式的重要特征

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

正确性(Correctness)

这些模式实际上会破坏您的代码并使您做错事。 以下是对此的简单说明 -

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))

可维护性(Maintainability)

如果程序易于理解和修改，则可以说是可维护的。 可以将导入模块视为可维护性的示例。

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

说明 (Explanation)

该示例包括演示在Python中创建函数的好的和坏的标准。

Python Design Patterns - Exception Handling

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

为何使用例外？

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

示例 - 除以零

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)

输出 (Output)

上述程序生成以下输出 -

提高例外

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

语法 (Syntax)

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