'''
1. 什么是异常处理
异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常
没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止
异常包含三个部分:
1. traceback异常的追踪信息
2. 异常的类型
3. 异常的信息
错误分为两大类:
1. 语法上的错误:在程序运行前就应该立即修正
2. 逻辑上的错误
2. 为何要异常处理
避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性
3. 如何异常处理
try:
代码1
代码2
代码3
......
except NameError:
当抛出的异常是NameError时执行的子代码块
except ....:
pass
except ...:
pass
else:
pass
finally:
pass
'''
# 1. 常见的逻辑错误导致的异常
# print('adsfsadf'
# age=input('>>: ').strip()
# print(age > 10) #TypeError
# for i in 10: #TypeError
# pass
# import os
# os.xxx #AttributeError
# 1 / 0 #ZeroDivisionError:
# print('=====1')
# print('=====2')
# print('=====3')
# l=[1,2,3]
# l[1000] #IndexError
# print('=====4')
# d={'x':1,'y':2}
# d['z'] #KeyError
# print('=====5')
# 2. 异常处理
# 异常处理的单分支
# try:
# 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:
# print('IndexError')
#
# print('other code')
# 异常处理的多分支
# try:
# 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 KeyError as e:
# print('KeyError',e)
# except IndexError as e:
# print('IndexError',e)
#
#
# print('other code')
# try:
# 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 (KeyError,IndexError) as e:
# print(e)
# print('other code')
# 万能异常类型Exception:可以匹配任意类型的异常
# try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# # d['z'] # KeyError
# # xxx
# 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:
# print('Exception:',e)
#
# print('other code')
# try... else...
# try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# # d['z'] # KeyError
# # xxx
# 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:
# print('Exception:',e)
# else:
# print('else必须放到后面,else的子代码块会在被检测的代码没有异常的情况下执行')
# # print('other code')
# try... finally...
# try:
# f=open('a.txt','w')
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# # d['z'] # KeyError
# # xxx
# 'xx' > 10
# 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:
# # print('Exception:',e)
# else:
# print('else必须放到后面,else的子代码块会在被检测的代码没有异常的情况下执行')
# finally:
# print('无论被检测的代码有没有异常都会执行')
# f.close()
# 主动触发异常
# print('===>1')
# print('===>2')
# raise TypeError('类型错误')
# print('===>3')
# 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) == 5
print('下半部分,处理数据')
元类:
8 #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))
# 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=sex
def 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)
#
# 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'
'''12'''
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的类才能称之为自定义的元类,否则就是只是一个普通的类
pass
class 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_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__)
'''
# 实例化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)
print(tea1.__dict__)
属性的查找:
class Mymeta(type): # 但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
# n=444
def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类
# 1. 先产生一个空对象
tea_obj = self.__new__(self) # tea_obj是OldboyTeacher这个类的对象
# print(self.__new__ is object.__new__)
# tea_obj=object.__new__(self)
# 2. 执行__init__方法,完成对象的初始属性操作
self.__init__(tea_obj, *args, **kwargs)
# 3. 返回初始化好的那个对象
return tea_obj
class Bar:
# n = 33
pass
class Foo(Bar):
# n = 222
pass
class OldboyTeacher(Foo, metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
# n = 111
school = 'Oldboy'
def __init__(self, name, age, sex):
self.name = name #None.name='egon'
self.age = age
self.sex = sex
def score(self):
print('%s is scoring' % self.name)
def __new__(cls, *args, **kwargs):
# print('=====>')
return super().__new__(cls)
tea1 = OldboyTeacher('egon', 18, 'male')
# print(tea1)
print(tea1.__dict__)
# print(OldboyTeacher.n)
# print(object.__new__)