1.异常处理
1. 什么是异常处理
异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常
没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止
异常包含三个部分:
1. traceback异常的追踪信息
2. 异常的类型‘’
3. 异常的信息
错误分为两大类:
1. 语法上的错误:在程序运行前就应该立即修正
2. 逻辑上的错误
2. 为何要异常处理
避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,
从而增强程序的健壮性
3. 如何异常处理
try:
代码1
代码2
代码3
......
except NameError:
当抛出的异常是NameError时执行的子代码块
except ....:
pass
except ...:
pass
else:
pass(else必须放到后面,else的子代码块会在被检测的代码没有
异常的情况下执行)
finally:
pass(无论被检测的代码有没有异常都会执行,可用来回收资源)
4.异常的种类
AttributeError 试图访问一个对象没有的属性，比如foo.x，
但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，
却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，
写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，
基本上是由于另有一个同名的全局变量，导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
5.主动触发异常
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)
obj.set_info('egon','1') TypeError: 年龄必须是int类型
obj.set_info(1,18) TypeError: 名字必须是str类型
6.# 自定义异常类型(了解)
class MyException(BaseException):
def __init__(self,msg):#传入参数msg,即异常类型
super().__init__()
self.msg=msg
def __str__(self):
return '<%s>' %self.msg
raise MyException('我自定义的异常')
注意：使用自定义异常类型时，必须先抛出异常，再用except捕获自定义异常
2.元类
1 什么是元类:
源自一句话:在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)) <class '__main__.OldboyTeacher'>
print(type(OldboyTeacher)) <class 'type'>
对象tea1是调用OldboyTeacher类得到的,如果说一切皆对象,那么
OldboyTeacher也是一个对象,只要是对象,都是调用一个类实例化得到的,
即OldboyTeacher=元类(...),内置的元类是type
关系:
1. 调用元类---->自定义的类
2. 调用自定义的类---->自定义的对象
class关键字创建自定义类的底层的工作原理,分为四步
1. 先拿到类名:'OldboyTeacher'
2. 再拿到类的基类们:(object,)
3. 然后拿到类的名称空间???(执行类体代码,将产生的名字放到类的名称空间
也就是一个字典里,补充exec)
4. 调用元类实例化得到自定义的类:
OldboyTeacher=type('OldboyTeacher',(object,),{...})
自定义类的三个关键组成部分:
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=sex
def score(self):
print('%s is scoring' %self.name)
"""
exec(class_body,{},class_dic)
print(class_dic)
{'school': 'Oldboy', '__init__': <function __init__ at 0x00000254E0DFA0D0>, 'score': <function score at 0x00000254E0F619D8>}
4. 调用type得到自定义的类
OldboyTeacher=type(class_name,class_bases,class_dic)
print(OldboyTeacher)
<class '__main__.OldboyTeacher'>
tea1=OldboyTeacher('egon',18,'male')
print(tea1.__dict__)
{'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):
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):
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)
TypeError: 类体中必须有文档注释,且文档注释不能为空
__call__
class 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_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) <__main__.OldboyTeacher object at 0x00000200B9C63748>
print(tea1.__dict__) {'name': 'egon', 'age': 18, 'sex': 'male'}
# 实例化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)
# # 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) <__main__.OldboyTeacher object at 0x000002358DE137F0>
# print(tea1.__dict__)
{'_OldboyTeacher__name': 'egon', '_OldboyTeacher__age': 18,
'_OldboyTeacher__sex': 'male'}
属性查找:属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，
另外一个层则是类层（即元类层）的查找
