Day29、Python中的异常处理及元类

一、异常处理

　　异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止。为了避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性

　　异常包含三个部分:
　　　　1. traceback异常的追踪信息
　　　　2. 异常的类型
　　　　3. 异常的信息

　　错误分为两大类:
　　　　1. 语法上的错误:在程序运行前就应该立即修正
　　　　2. 逻辑上的错误

简单的异常处理代码：

try:
    代码1
    代码2
    代码3
    ......
except NameError:
    当抛出的异常是NameError时执行的子代码块
except Exception:
    pass
else:
    pass
finally:
    pass

Python中标准的异常提示：

BaseException    所有异常的基类
SystemExit    解释器请求退出
KeyboardInterrupt    用户中断执行(通常是输入^C)
Exception    常规错误的基类
StopIteration     迭代器没有更多的值
GeneratorExit     生成器(generator)发生异常来通知退出
StandardError    所有的内建标准异常的基类
ArithmeticError     所有数值计算错误的基类
FloatingPointError     浮点计算错误
OverflowError    数值运算超出最大限制
ZeroDivisionError    除(或取模)零 (所有数据类型)
AssertionError    断言语句失败
AttributeError    对象没有这个属性
EOFError     没有内建输入,到达EOF 标记
EnvironmentError     操作系统错误的基类
IOError     输入/输出操作失败
OSError     操作系统错误
WindowsError    系统调用失败
ImportError     导入模块/对象失败
LookupError     无效数据查询的基类
IndexError    序列中没有此索引(index)
KeyError    映射中没有这个键
MemoryError    内存溢出错误(对于Python 解释器不是致命的)
NameError    未声明/初始化对象 (没有属性)
UnboundLocalError     访问未初始化的本地变量
ReferenceError    弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError     一般的运行时错误
NotImplementedError    尚未实现的方法
SyntaxError    Python 语法错误
IndentationError    缩进错误
TabError    Tab 和空格混用
SystemError     一般的解释器系统错误
TypeError    对类型无效的操作
ValueError     传入无效的参数
UnicodeError     Unicode 相关的错误
UnicodeDecodeError     Unicode 解码时的错误
UnicodeEncodeError     Unicode 编码时错误
UnicodeTranslateError    Unicode 转换时错误
Warning     警告的基类
DeprecationWarning    关于被弃用的特征的警告
FutureWarning     关于构造将来语义会有改变的警告
OverflowWarning    旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning    关于特性将会被废弃的警告
RuntimeWarning     可疑的运行时行为(runtime behavior)的警告
SyntaxWarning    可疑的语法的警告
UserWarning    用户代码生成的警告

标准异常

try ... except简单案例：

try:
    k = {'a': 1, 'b': 2}
    print(k['x'])
    l1 = [1,2,3]
    l1[100]
except IndexError as e:
    print(123,e)

异常处理的多分支：

try:
    k = {'a': 1, 'b': 2}
    # print(k['x'])
    l1 = [1,2,3]
    l1[100]
except IndexError as e:
    print('IndexError',e)
except KeyError as e:
    print('KeyError',e)

万能异常Exception：可以匹配任意类型的异常：

try:
    k = {'a': 1, 'b': 2}
    print(k['x'])
    l1 = [1,2,3]
    l1[100]
except Exception as e:
    print(e)

try ... else ... 结构：

try:
    k = {'a': 1, 'b': 2}
    print(k['x'])
    l1 = [1,2,3]
    l1[100]
except Exception as e:
    print(e)
else:
    print('else必须放到后面,else的子代码会在被检测的代码块没有异常的情况下执行')

try... finally... 结构：

try:
    k = {'a': 1, 'b': 2}
    print(k['x'])
    l1 = [1,2,3]
    l1[100]
except Exception as e:
    print(e)
else:
    print('else必须放到后面,else的子代码会在被检测的代码块没有异常的情况下执行')
finally:
    print('无论被检测的代码有没有异常都会执行')

主动触发异常一自定义异常：

# 主动触发异常
raise TypeError("类型错误")
#
# 自定义异常类型
class MyException(BaseException):
    def __init__(self,msg):
        super().__init__()
        self.msg = msg
    def __str__(self):
        return '%s'%self.msg

二、元类

　　在python中,一切皆对象,而对象都是由类实例化得到的,所以通俗的说类也是一个对象,而类就是元类的实例化

class OldboyTeacher:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex =sex

    def score(self):
        print('打分')
tea1 = OldboyTeacher('Yven',19,'male')
print(type(OldboyTeacher))# class 'type'>得到元类type
# tea1一定是调用OldboyTeacher得到的，如果一切皆对象那么OldboyTeacher也是一个对象，
# 只要是对象都是调用一个类实例化得到的，即OldboyTeacher = 元类(...),内置的元类是type

　　所以元类,类与对象的关系为:

　　　　1.调用元类----->自定义的类

　　　　2.调用自定义的类----->自定义类的对象

　　从而分析class关键字创建自定义类的底层工作原理,分为四步:

　　　　1.先拿到类名

　　　　2.再拿到类的父类们

　　　　3.然后拿到类发名称空间(执行类体代码,将产生的名字放到类的名称空间也就是一个字典中)

　　　　4.调用元类实例化得到自定义的类

自定义元类来控制类的产生：

1、类名必须用驼峰体
2、类体必须有文档注释,且文档注释不能为空

class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
    def __init__(self,class_name,class_bases,class_dic):
        if class_name.islower():
            raise TypeError('类名必须使用驼峰体')

        doc=class_dic.get('__doc__')
        if doc is None or len(doc) == 0 or len(doc.strip('
 ')) == 0:
            raise TypeError('类体中必须有文档注释,且文档注释不能为空')

class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
    school = 'Oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def score(self):
        print('%s is scoring' %self.name)


print(OldboyTeacher.__dict__)

自定义元类来控制类调用的过程：

1、先产生一个空对象
2、执行__init__方法,完成对象的初始属性操作
3、返回初始化好的那个对象

class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
    def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类,args=('egon',18,'male'),kwargs={}
        # 1. 先产生一个空对象
        tea_obj=self.__new__(self) #tea_obj是OldboyTeacher这个类的对象
        # 2. 执行__init__方法,完成对象的初始属性操作
        self.__init__(tea_obj,*args,**kwargs)
        # print(tea_obj.__dict__)
        tea_obj.__dict__={('_%s__%s' %(self.__name__,k)):v for k,v in tea_obj.__dict__.items()}
        # 3. 返回初始化好的那个对象
        return tea_obj

class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
    school = 'Oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def score(self):
        print('%s is scoring' %self.name)

tea1=OldboyTeacher('egon',18,'male') # 会触发OldboyTeacher的类(即元类)中的__call__函数
# print(tea1)
print(tea1.__dict__)