异常信息处理与元类

异常信息处理

什么是异常处理：

　　程序出现异常，被抛出来的错误信息，然后程序终止

(1)异常处理单分支

　　从上到下一次捕获

(2)异常处理多分支

try:
    代码1
    代码2
    代码3
    ......
except NameError:    # 一旦该语句被异常捕获,代表该条语句没有被执行
    当抛出的异常是NameError时执行的子代码块
except ....:
    TypeError   
    pass
except ...:
    pass
else:    #else的子代码块会在被检测的代码没有异常的情况下执行
    pass
finally:  #  无论被检测的代码有没有异常都会执行
    pass



# 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:   #将捕获到的信息赋值给e
#     print(e)
# print('other code')

(3)万能异常捕获  Exception

主动触发异常    raise

print('===>1')
print('===>2')
raise TypeError('类型错误')
print('===>3')

 自定义异常类型

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,5]

assert len(l) == 5

 

 

 

元类  （一切皆对象）

 

元类（type)：是用来产生类

一切皆对象：对象通过类来实例化，那么类通过元类来实例化

自定义类：

　　先 exex 拿到局部名称空间

　　在 type(定义的类名，定义的基类（object,)，拿到的局部名称空间）

　　得到类

name = 'people'  # 自定义的类名
bass_name = (object,)  # 基类用元祖保存，且必须继承object
name_str = '''   
x = 1
def auth():
    pass
'''
name_dic = {}   # 产生空名称空间

exec(name_str,{},name_dic)    # 往名称空间里丢名字
people = type(name,bass_name,name_dic)

print(name_dic)     # 得到局部名称空间
print(people.x)

# exec(注释多行的字符串，全局变量(用任意字符代替),局部变量）     将名字往局部名称里保存
# type(定义的类名，定义的基类(元祖形式),局部名称空间）

 

自定义元类：（自己来限制类名，通过__init__来控制类名，以及类名称空间里的东西）

# 自定义元类(元类实例化产生类)
# 如何自定义元类：元类实例化产生类(这时的类相当于一个对象）
# 如何证明定义的是元类：
    # 1 必须继承 type 才能称为元类
    # 2 实例化得到类

# type(定义的类名，定义的基类(元祖形式),局部名称空间）

# 自定义元类实例化产生一个类
# __init__ 可以控制类名，以及文档的一些要求
# __doc__ 用来查看类里面是否文档注释

class people(type):# 元类
    # type(定义的类名，定义的基类(元祖形式),局部名称空间）
    # 自己的类名, 继承的基类（object,),类的名称空间
    def __init__(self,class_name,bassclass,class_dic):
        pass
# object 是默认基类，可以不写
class auth(object,metaclass=people):  # auth = people('auth',(object,),auth的名称空间）
    pass

print(auth.__dict__)
print(auth)

 自定义元类： （自己来限制类的对象，通过__call__来限制对象的产生）

# 自定义 元类来控制类的对象产生  __call__
# 类实例化发生三件事
# 1, 第一件事： 先拿到一个对象的名称空间
# 2  第二件是： 执行类里面的__init_方法
# 3  第三件事： 得到一个对象
class Teacher(type):
    def __call__(self, *args, **kwargs):
        stu_obj = self.__new__(self)
        self.__init__(stu_obj,*args,**kwargs)
        return stu_obj

class Student(metaclass=Teacher):
    def __init__(self,name,age):
        self.name = name
        self.age = age