什么是异常处理：
异常就是错误发生的信号，一旦程序出错就会产生一个异常，如果该异常没有被应用程序处理，那么该异常就会抛出来，程序的执行也就随之终止
异常包含三个部分：
1.traceback异常的追踪信息
2.异常的类型
3.异常的信息
错误分为两大类：
1.语法上的错误：在程序运行前就应该立即修正
2.逻辑上的错误
为何要异常处理
try
代码1
代码2
代码3
.......
except NameError:
当抛出的宜昌市是nameerror时执行的子代码块
except ....:
pass
.....
try：
print('adsada')
l=[1,2,3]
l[3]
except KeyError e:
print('Key Error',e)
这是异常的单分支
多分支就是有多个except 但是有异常有一个分支触发了就直接终止了
Exception是一个万能异常类型 可以匹配任意类型的异常
try：
print('adsada')
l=[1,2,3]
l[3]
except KeyError as e:
print('Key Error',e)
except ValueError as n:
print('Value Error',n)
else:
print('111') else必须放到后面，else的子代码会在被检测的代码没有异常的情况下执行
finally:
print('222') finally 是无论被检测的代码有没有异常都会执行
raise 可以主动触发异常
自定义异常类型：自定义的类继承BaseException
什么是元类：
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(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. 类名 （class_name）
2. 类的基类们 （class_bases）
3. 类的名称空间 （class_dic）
不依赖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=sex
def score(self):
print('%s is scoring' %self.name)
"""
4. 调用type得到自定义的类
OldboyTeacher=type(class_name,class_bases,class_dic)
print(OldboyTeacher)
tea1=OldboyTeacher('egon',18,'male')
print(tea1.__dict__)
打印结果
<class '__main__.OldboyTeacher'>
{'name': 'egon', 'age': 18, 'sex': 'male'}
自定义元类来控制类的产生
模板：
class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
def __init__(self,class_name,class_bases,class_dic):
print(self)
print(class_name)
print(class_bases)
print(class_dic)
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)
控类的产生
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__)
实例化OldboyTeacher,或者说调用OldboyTeacher会
1. 先产生一个空对象
2. 执行__init__方法,完成对象的初始属性操作
3. 返回初始化好的那个对象
推导:调用OldboyTeacher(...)就是在调用OldboyTeacher的类中的__call__,那么在该__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_obj
class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
school = 'Oldboy'
# tea_obj,'egon',18,'male'
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__)