异常处理
1. 什么是异常处理
异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常
没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止异常包含三个部分:
1. traceback异常的追踪信息
2. 异常的类型3. 异常的信息错误分为两大类:
1. 语法上的错误:在程序运行前就应该立即修正
2. 逻辑上的错误2. 为何要异常处理
避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性
3. 如何异常处理
try: f=open('a.txt','w') print('=====1') print('=====2') print('=====3') d = { 'x': 1, 'y': 2} d['z'] #KeyError print('=====4') l = [1, 2, 3] l[1000] #IndexError print('=====5') except IndexError as e: print('IndexError:', e) except KeyError as e: print('KeyError:', e) except Exception as e:# 万能异常类型Exception:可以匹配任意类型的异常 print('Exception:',e) else: print('else必须放到后面,else的子代码块会在被检测的代码没有异常的情况下执行') finally: print('无论被检测的代码有没有异常都会执行') f.close()
主动触发异常
class People: def __init__(self,name,age): self.__name=name self.__age=age def tell_info(self): print(self.__name,self.__age) def set_info(self,name,age): if not isinstance(name,str): raise TypeError('名字必须是str类型') if not isinstance(age,int): raise TypeError('年龄必须是int类型') self.__name=name self.__age=age obj=People('egon',18) print(obj.__dict__) obj.tell_info() obj.set_info('egon',123) obj.tell_info()
自定义异常类型(了解)
class MyException(BaseException): def __init__(self,msg): super().__init__() self.msg=msg def __str__(self): return '<%s>' %self.msg raise MyException('我自定义的异常')
断言(了解)
print('上半部分,生产数据')l=[1,2,3,4]if len(l) != 5: raise TypeError('列表的长度必须为5')assert len(l) == 5print('下半部分,处理数据')
元类介绍
什么是元类:
源自一句话:在python中,一切皆对象,而对象都是由类实例化得到的
class OldboyTeacher: 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')print(type(tea1))print(type(OldboyTeacher))
对象tea1是调用OldboyTeacher类得到的,如果说一切皆对象,那么OldboyTeacher也是一个对象,只要是对象
都是调用一个类实例化得到的,即OldboyTeacher=元类(...),内置的元类是type关系:
1. 调用元类---->自定义的类
2. 调用自定义的类---->自定义的对象
class关键字创建自定义类的底层的工作原理,分为四步
1. 先拿到类名:'OldboyTeacher'2. 再拿到类的基类们:(object,)3. 然后拿到类的名称空间???(执行类体代码,将产生的名字放到类的名称空间也就是一个字典里,补充exec)4. 调用元类实例化得到自定义的类: OldboyTeacher=type('OldboyTeacher',(object,),{...})class OldboyTeacher: OldboyTeacher=type(...) 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) 自定义类的三个关键组成部分:
1. 类名2. 类的基类们3. 类的名称空间不依赖class关键字创建一个自定义类
1. 拿到类名
class_name='OldboyTeacher'
2. 拿到类的基类们:(object,)
class_bases=(object,)
3. 拿到类的名称空间
class_dic={}class_body="""school = 'Oldboy'def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sexdef score(self): print('%s is scoring' %self.name)"""exec(class_body,{},class_dic)print(class_dic)
4. 调用type得到自定义的类
OldboyTeacher=type(class_name,class_bases,class_dic)print(OldboyTeacher)print(OldboyTeacher.school)print(OldboyTeacher.score)tea1=OldboyTeacher('egon',18,'male')print(tea1.__dict__)
自定义元类来控制类的产生
模板
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 def __init__(self,class_name,class_bases,class_dic): print(self) print(class_name) print(class_bases) print(class_dic)classOldboyTeacher(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)
控类的产生
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('\n ')) == 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__)
自定义元类来控制类调用的过程
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类 passclass OldboyTeacher(object): 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) def __call__(self, *args, **kwargs): print(self) print(args) print(kwargs)tea1=OldboyTeacher('egon',18,'male')tea1(1,2,a=1,b=2)# __call__(tea1,(1,2).{'a':1,'b':2}) 总结:对象之所以可以调用,是因为对象的类中有一个函数__call__
推导:如果一切皆对象,那么OldboyTeacher也是一个对象,该对象之所可以调用,肯定是这个对象的类中也定义了一个函数__call__
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) #3. 返回初始化好的那个对象 return tea_objclass OldboyTeacher(object,metaclass=Mymeta): OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...}) school = 'Oldboy' def __init__(self,name,age,sex):#tea_obj,'egon',18,'male' 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__) 实例化OldboyTeacher,或者说调用OldboyTeacher会
1. 先产生一个空对象2. 执行__init__方法,完成对象的初始属性操作3. 返回初始化好的那个对象推导:调用OldboyTeacher(...)就是在调用OldboyTeacher的类中的__call__,那么在该__call__中就需要做上述三件事自定义元类来控制类的调用(即类的实例化过程)
举例：
# 自定义轿车元类CarMeta
# -- 实现元类为CarMeta的类至少有生产日期(production_date)、发动机编号(engine_number)及载客量(capacity)三个基本属性在__init__里做限制，不用调用类
class AttributeError(BaseException): def __init__(self,msg): super().__init__() self.msg=msg def __str__(self): return self.msgclass CarMeta(type): def __init__(self,class_name,class_bases,class_dic): dic=class_dic if not ('pro_date' in dic and 'en_number' in dic and 'capacity' in dic): raise AttributeError('必须有生产日期、发动机编号及载客量')class Tesla(metaclass=CarMeta): name='123' pro_date =1 en_number = 2
在__call__里做限制，如果你要调用Tesla类来生成对象的话
class AttributeError(BaseException): def __init__(self, msg): super().__init__() self.msg = msg def __str__(self): return self.msgclass CarMeta(type): def __call__(self, *args, **kwargs): obj=self.__new__(self) self.__init__(obj,*args,**kwargs) if not ('pro_date' in obj.__dict__ and 'en_number' in obj.__dict__ and 'capacity' in obj.__dict__): raise AttributeError('必须有生产日期、发动机编号及载客量') return objclass Tesla(metaclass=CarMeta): def __init__(self,production_date,engine_number): self.pro_date=production_date self.en_number=engine_numberalex=Tesla(1,2) 属性查找
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类 n=444 def __call__(self, *args, **kwargs): #self=obj=self.__new__(self) self.__init__(obj,*args,**kwargs) return objclass Bar(object): n=333class Foo(Bar): n=222class OldboyTeacher(Foo,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)print(OldboyTeacher.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为OldboyTeacher->Foo->Bar->object->Mymeta->type
查找顺序：1、先对象层：OldoyTeacher->Foo->Bar->object2、然后元类层：Mymeta->type
