python中的异常模式和设计模式

异常的引入

• 概念
  异常就是不正常，当python检测到一个错误时，解释器就无法继续执行下去了，反而出现了一些错误的提示，这就是所谓的异常。

捕获异常

• try—except

案例：从键盘输入被除数与除数，求商并打印

• 传统解决方法
• 使用异常处理的解决方法
• except 多个异常

-多个异常分开写(注意异常<父子>类的顺序)

try:
	<语句>        
except <异常类名字>：
	<语句>        
except <异常类名字>:
	<语句>        
else:
    #如果没有异常发生
	<语句>  

• 多个异常写到一个元组中

try:
    代码
except(Exception1[,Exception2[,...ExceptionN]]]):
   	发生以上多个异常中的一个，执行这块代码
''''

• 获取异常信息

try:
    f = open('124.txt', 'r')
    f.write('HelloWorld')
#将捕获到的异常存储到到变量errMsg中
except IOError as errMsg:
    print(errMsg)

• 捕获所有异常

  • except 不带任何异常

try:
    a = 2/0
except:
    print("遇到异常")

• except 父类Exception

try:
    b = 3/0
except BaseException as result:
    print(result)

• 捕获异常中else的用法

try:
    b = 3/1
except BaseException as result:
    print(result)
else:
    # 可以访问b的值
    print("没有遇到异常,结果为:%d"%b)

• try— finally finally顾名思义： 最终，最后的意思

  • 用处
    确保最后一定要执行的，比如：文件关闭、数据库关闭、socket关闭，等…
  • 案例：（文件关闭问题）

try:
    f = open('123.txt', 'r')
    # 如果遇到异常，后续代码不再执行，直接执行except模块
    f.write('HelloWorld')
    # 在这关闭文件是否合适
    f.close()
except IOError as errMsg:
    print(errMsg)
else:
    print("写入文件成功")
finally:
    # 最终一定要关闭文件（打印，验证是否执行）
    f.close()
    print("finally，文件关闭")

抛出自定义异常

• 自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。
异常应该是典型的继承自Exception类，通过直接或间接的方式
#自定义异常类，直接或者间接继承Exception
class GenderException(Exception):
def init(self):
super().init()
# args 为BaseException的属性
self.args = ‘性别只能为男或者女’
# 也可以自定义一个属性
self.msg = ‘性别只能为男或者女’

• 手动抛出自定义异常
  • 语法： raise [Exception [, args [, traceback]]]

class Student(object):
    def __init__(self, name, gender, age):
        self.__name = name
        self.setGender(gender)
        self.__age = age
    def setGender(self, gender):
        if gender == '男' or gender == '女':
            self.__gender = gender
        else:
            # 抛出一个自定义的性别异常(也可以以列表的形式抛出多个异常)
            # raise [GenderException(), Exception()]
            raise GenderException()
try:
    stu1 = Student('大黄', '男1', 18)
except GenderException as e:
    # 打印自定义的信息
    print(e.msg)
    # 打印父类属性的信息
    print(e.args)

设计模式

• 概念
  是一种常用的软件设计模式，应用该模式的类一个类只有一个实例，即一个类只有一个对象实例。
• 作用：
  • 保证全局对象的唯一性
• 用法
  因为创建对象时，会默认调用__new__,以及__init__方法，所以，需要重写这两个方法完成
  注意点： 对象唯一，只进行一次初始化
  #保证创建对象的唯一性，需要重写__new__方法
• 使用场景（购物车）

class ShoppingCart():
    __hasCart = None
    __hasInit = False
    def __new__(cls, *args, **kwargs):
        if not cls.__hasCart:
            cls.__hasCart = object.__new__(cls)
        return cls.__hasCart
    def __init__(self):
        if not self.__hasInit:
            self.shopping_list = []
            ShoppingCart.__hasInit = True
s1 = ShoppingCart()
s1.shopping_list.append('苹果1个')
s2 = ShoppingCart()
s2.shopping_list.append('手机一个')
print(id(s1))
print(s1.shopping_list)
print(id(s2))
print(s2.shopping_list)

工厂模式

• 工厂模式是一个在软件开发中用来创建对象的设计模式。 当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工 厂模式。在如此情形中，实现代码基于工厂模式，可以达到可扩展，可维护的代 码。当增加一个新的类型，不在需要修改已存在的类，只增加能够产生新类型的 子类
• 案例：

class Car(object):
    def run(self):
        print('吧里吧里的跑...')
    def stop(self):
        print('蹭蹭的停车...')
class BMW(Car):
    def run(self):
        print('宝马-->>>吧里吧里的跑...')
    def stop(self):
        print('宝马-->>>蹭蹭的停车...')
class Benz(Car):
    def run(self):
        print('奔驰-->>>吧里吧里的跑...')
    def stop(self):
        print('奔驰-->>>蹭蹭的停车...')
class Skoda(Car):
    def run(self):
        print('斯柯达-->>>吧里吧里的跑...')
    def stop(self):
        print('斯柯达-->>>蹭蹭的停车...')
class CarFactory(object):
    def new_car(self, name):
        if name == 'BMW':
            return BMW()
        if name == 'Benz':
            return  Benz()
        if name == 'skd':
            return Skoda()
class CarStore(object):
    def __init__(self, factory):
        self.factory = factory
    def order(self, name):
        new_car = self.factory.new_car(name)
        return new_car
car_factory = CarFactory()
car_store = CarStore(car_factory)
car = car_store.order('skd')
car.run()
car.stop()