一、异常处理
1.异常处理介绍：
异常是错误发生的信号，一旦程序出错就会产生一个异常，如果该异常没有被应用程序处理，那么该异常就会被抛出来，程序执行随之停止
2.异常通常包含三个部分
1.traceback异常的追踪信息
2.异常的类型
3.异常的信息
3.为何使用异常处理：
避免程序因为异常而奔溃，所以在应用程序中应该对异常进行处理，从而增强程序的健壮性
4.自定义处理异常的结构
1) try: except Exception as e:
2) try: except Exception: else:
3) try: except Exception: else: finally:
4) try: except...
5) try: finally:
else必须放到后面，else的代码块会在没有异常的情况下运行
finally：无论被检测的代码有无异常，都会运行，通常用于资源回收（列如 文件操作中途代码错误 可以在finally中定义回收代码）
自定义异常：（防止资源被无限占用，自定义规范）
"""
class MyException(BaseException):
# 构造自定义异常类对象
def __init__(self):
pass
# 格式化异常信息
def __str__(self):
pass
"""
自定义异常必须要继承
Exception：可以匹配任意类型的异常 被称为万能异常类型
![]()
![]()
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
一些常用异常
主动抛出异常：raise Exception（msg）
断言（了解）
# print('上半部分，生产数据')
# l = [1,2,3,4,5]
#
# # if len(l)!=5:
# # raise TypeError('列表的长度必须是5')
# assert len(l) ==5 #if的简化版本
# print('下半部分，处理数据')
二、元类
1.元类介绍：
源自于一句话，在python中，一切皆对象，而对象都是由类实例化得到的。简单的说 元类就是产生类的类
定义了一个类，类里有一个构造器和方法
class OldboyTeacher:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name)
tea1 = OldboyTeacher('egon',18,'male')
print(type(tea1))#<class '__main__.OldboyTeacher'>
print(type(OldboyTeacher))#<class 'type'>
从上面的代码中我们可以看出，对象teal调用OldboyTeacher类得到的，一切皆对象，OldboyTeacher也是一个对象，只要是对象，都是调用一个类的实例化方法得到的，即OldboyTeacher=元类，OldboyTeacher类的类型为type，内置元类就是type
class关键字创建自定义类的底层工作原理，分为四步：
1.先拿到类名：OldboyTeacher
2.再拿到类的基类们：object
3.然后拿到类的名称空间（执行类体代码，将产生的名字放到类的名称空间，也就是一个字典里）
4.调用元类来实例化得到自定义的类：OldboyTeacher = type（OldboyTeacher，（object，）{...}）
自定义类的三个关键组成部分：
1.类名
2.类的基类
3.类的名称空间
不依赖class类创建一个自定义类：
#1.拿到类名
clss_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)#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
print(class_dic)#{'school': 'Oldboy', '__init__': <function __init__ at 0x00000209D705C268>, 'score': <function score at 0x00000209D7208B70>}
# 4.调用type得到自定义的类
OldboyTeacher = type(clss_name,class_bases,class_dic)
tea1 = OldboyTeacher('egon',18,'male')
print(tea1.__dict__)#{'name': 'egon', 'age': 18, 'sex': 'male'}
补充exec：exec（）
#参数一：包含一系列python代码的字符串
#参数二：全局作用域（字典形式），如果不指定，默认为globals()
#参数三：局部作用域（字典形式），如果不指定，默认为locals()
#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
将class_body中产生的名称空间都存放在class_dic的列表中
2.自定义元类来控制类的产生
注：只有继承了type类的类才能称之为自定义的元类，否则就是一个普通的类
以一个例子来说明使用方法：
#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,)，{...}）
'''
'''
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name)
3.自定义元类来控制类调用过程
对象之所以可以调用，是因为对象的类中有一个函数__call__，那么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'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name)
tea1 = OldboyTeacher('egon',18,'male')#会触发OldboyTeacher的类，即元类中的__call__
回顾一下类的实例化步骤：
1.先产生一个空对象
2.执行__init__方法，完成对象的初始化属性操作
3.返回初始化好的那个对象
4.属性查找
![]()
![]()
class Mymeta(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__)
View Code
#查找顺序：
#1、先对象层：OldoyTeacher->Foo->Bar->object
#2、然后元类层：Mymeta->type
总结，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都没有找到__new__的情况下，会去找object里的__new__，而object下默认就有一个__new__，所以即便是之前的类均未实现__new__,也一定会在object中找到一个，
根本不会、也根本没必要再去找元类Mymeta->type中查找__new__但我们还是推荐在__call__中使用self.__new__（self）去创造空对象，因为这种方式会检索三个类OldboyTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个
焚膏油以继晷，恒兀兀以穷年。
