【Python学习之八】设计模式和异常

环境
　　虚拟机：VMware 10
　　Linux版本：CentOS-6.5-x86_64
　　客户端：Xshell4
　　FTP：Xftp4
　　python3.6

一、设计模式
1、单例模式
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

class Singleton(object):
    __instance=None
    __first_init=False
    
    def __new__(cls,name,age):
        if not cls.__instance:
            cls.__instance=object.__new__(cls);
        return cls.__instance
    def __init__(self,name,age):
        if not self.__first_init:
            self.name=name
            self.age=age
            Singleton.__first_init=True

a=Singleton('bin',18)
b=Singleton('bin',8)
#只有一个实例
print(id(a))
print(id(b))
#只初始化一次
print(a.age)
print(b.age)
#修改属性
a.age=19
print(b.age)

2、工厂模式
2.1、Simple Factory模式不是独立的设计模式，他是Factory Method模式的一种简单的、特殊的实现。他也被称为静态工厂模式，通常创建者的创建方法被设计为static方便调用。
(1)静态的工厂类
(2)用全局函数改写工厂类

class Person(object):
    def __init__(self,name):
        self.name=name
    def work(self,type):
        print('%s开始工作了'%self.name)
        ax=Factory.create_axe(self, type)
        ax.cut_tree()
        
class Axe(object):
    def cut_tree(self):
        print('开始砍树了')
class StoneAxe(Axe):
    def cut_tree(self):
        print('石斧砍树')
class SteelAxe(Axe):
    def cut_tree(self):
        print("使用钢斧头砍树")
class WaterAxe(Axe):
    def cut_tree(self):
        print("使用水砍树")    
    
class Factory(object):
    @staticmethod
    def create_axe(self,ax_type):
        if ax_type=='stone':
            return StoneAxe()
        elif ax_type=='steel':
            return SteelAxe()
        elif ax_type=='water':
            return WaterAxe()
        else:
            print('类型错误')
p=Person('光头强')#光头强开始工作了
p.work('steel')#使用钢斧头砍树

2.2、工厂方法模式
工厂方法模式去掉了简单工厂模式中工厂方法的静态方法，使得它可以被子类继承。对于python来说，就是工厂类被具体工厂继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。
抽象的工厂类提供了一个创建对象的方法，也叫作工厂方法。
(1) 抽象工厂角色（Factory）： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
(2) 具体工厂角色（Stone_Axe_Factory,Steel_Axe_Factory）：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
(3) 抽象产品角色(Axe)：它是具体产品继承的父类或者是实现的接口。在python中抽象产品一般为父类。
(4) 具体产品角色(Stone_Axe,Steel_Axe)：具体工厂角色所创建的对象就是此角色的实例。由一个具体类实现。

二、异常
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
1、捕获异常

try:
    f=open('123.txt','r')
except IOError:
    print('文件打开报错')

2、当捕获多个异常时，可以把要捕获的异常的名字，放到except 后，并使用元组的方式仅进行存储

try:
    f=open('123.txt','r')
    print(num) 
except (IOError,NameError):
    pass

3、获取异常的信息描述

try:
    f=open('123.txt','r')
except Exception as result:
    print(result)

4、捕获所有异常

except后面不跟具体错误类型或者跟Exception

try:
    f=open('123.txt','r')
except:
    pass
或
try:
    f=open('123.txt','r')
except Exception as result:
    print(result)

5、else,如果没有捕获到异常，那么就执行else中的事情

try: 
    num = 100
    print(num) 
except NameError as errorMsg: 
    print('产生错误了:%s'%errorMsg) 
else: 
    print('没有捕获到异常，真高兴')

6、 try...finally...

在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。

import time
try:
    f=open('txt')
    try:
        while True:
            content=f.readline()
            if len(content)==0:
                break
            print(content)
            time.sleep(2)
    except TypeError as ex:
        pass
    finally:
        f.close()
        print('关闭文件')
except:
    print('没有这个文件')

7、异常的传递

如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递

如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样.

8、自定义异常
用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类。

class ShortInputException(Exception):
    def __init__(self,length,atleast):
        super().__init__()
        self.length=length
        self.atleast=atleast
def main():
    try:
        s=input('请输入->')
        if len(s)<3:
            raise ShortInputException(len(s),3) 
    except ShortInputException as result:
        print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast))
    else:
        print('没有异常发生.')

9、异常处理中抛出异常

class Test(object):
    def __init__(self,switch):
        self.switch=switch
    def cacl(self,a,b):
        try:
            return a/b
        except Exception as ex:
            if self.switch:
                print("捕获开启，已经捕获到了异常，信息如下:") 
                print(result)
            else:
                raise
a=Test(True)
a.cacl(11, 0)
print("----------------------华丽的分割线----------------") 
a.switch = False 
a.calc(11,0)

参考：
Python学习笔记