面向对象 - 异常处理 - 总结

面向对象 - 异常处理：
  1.什么是异常：异常是错误发生的信号，一旦程序出错，并且程序没有处理这个错误，那就会抛出异常，并且程序的运行随之终止

2.错误分为两种：
    2.1.语法错误 程序执行前就要立刻改正过来
    2.2.逻辑错误：
        1.ValueError         int('aaa')
        2.NameError          name
        3.IndexError         l=[1,2,3]  l[100]
        4.KeyError           d={} d['name']
        5.AttributeError     class Foo:pass  Foo.xxx
        6.ZeroDivisionError  1/0
        7.TypeError          for i in 3:pass
3.异常的种类：
    在python中不同的异常可以用不同的类型（python中统一了类与类型，类型即类）去标识，一个异常标识一种错误
    常见异常：
        AttributeError      试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
        IOError             输入/输出异常；基本上是无法打开文件
        ImportError         无法引入模块或包；基本上是路径问题或名称错误
        IndentationError    语法错误（的子类） ；代码没有正确对齐
        IndexError          下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
        KeyError            试图访问字典里不存在的键
        KeyboardInterrupt   Ctrl+C被按下
        NameError           使用一个还未被赋予对象的变量
        SyntaxError         Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
        TypeError           传入对象类型与要求的不符合
        UnboundLocalError   试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
        ValueError          传入一个调用者不期望的值，即使值的类型是正确的
    更多异常：
        ......
4.异常处理  ---》 （不能让程序出错一点异常 就整个崩溃  需要检测异常 ）
    1.对于错误发生的条件 如果是可以预知的 此时应该用if 判断去预防异常.
        age=input('>>:').strip()
        if age.isdigit():    # 发生异常是可预知的 把异常拒掉了
            age=int(age)
    2.对于错误发生的条件 如果是不可预知的 此时应该用异常处理机制try...except
        try...except 异常已经出现了 捕捉到 可以让程序继续运行
        try:
            ...
        except StopIteration:
            print('出错了')
        print('--------')
5.try...except 详细用法：
     1.异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
     2.多分支:被检测的代码块抛出的异常有多种可能性，并且我们需要针对每一种异常类型都定制专门的处理逻辑
     3.万能异常：Exception 被检测的代码块抛出的异常有多种可能性，并且我们针对所有的异常类型都只用一种处理逻辑就可以了，那就使用 Exception
     4.NameError/IndexError  Exception 联合使用  走了NameError/IndexError 就不会在走 Exception
     5.其他结构 try...except  else  finally #用来回收资源 else:没有发生异常时执行 finally:无论有没有异常都执行 这里一般用来回收资源f.close()
     6.主动触发异常：raise  异常类型（值）  eg: raise TypeError('名字必须为str')
     7.自定义异常类型 ==》 类型 = 类   class MyException(BaseException):...  raise MyException('自定义的异常')
     8.断言assert  下面的代码 依赖上面的代码 的结果   AssertionError
     9.使用异常时注意：代码不能随便乱用 try...except Exception .. 否则失去了写代码的意义
     10.什么情况使用异常呢？
        1.错误发生的异常能明确预知
        2.错误一定会发生，无法预知它发生的条件,不能让程序奔溃掉 才采用try...except

# print('1')
# int('q')
# asd
# l=[1,2,3]
# print(l[100])
# d={}
# print(d['name'])
# class Foo:
#     pass
# Foo.xx
# 1/0
# for i in 3:
#     pass
# import time
# time.sleep(100)
# int('as')
# AGE=10
# age=input('>>:').strip()
# if age.isdigit():
#     age=int(age)
#     if age>AGE:
#         print('猜大了')
# f=open('a.txt','r',encoding='utf-8')
# # print(f.__next__())
# # print(f.__next__())
# # print(f.__next__())
# try:
#     print(next(f),end='')
#     print(next(f),end='')
#     print(next(f),end='')
#     print(next(f),end='')
# except StopIteration as e:
#     print(e,'出错了')
#
# print('-----------')

# -----------------------
# try...except...用法
# 1.异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
# s='hello'
# try:
#     int(s)
# except ValueError as e:
#     print(e)
# print('---------------')
# 2.多分支:被检测的代码块抛出的异常有多种可能性，
# 并且我们需要针对每一种异常类型都定制专门的处理逻辑
# try:
#     print('--1--')
#     # name
#     print('--2--')
#     l=[1,2,3]
#     # l[100]
#     print('--3--')
#     d={}
#     # d['name']
#     print('--4--')
#
# except NameError as e:
#     print(e)
#
# except IndexError as e:
#     print(e)
#
# except KeyError as e:
#     print(e)
#
# print('----end----')
# 3.万能异常：Exception 被检测的代码块抛出的异常有多种可能性，
# 并且我们针对所有的异常类型都只用一种处理逻辑就可以了，那就使用 Exception
# try:
#     print('--1--')
#     # name
#     print('--2--')
#     l=[1,2,3]
#     l[100]
#     print('--3--')
#     d={}
#     # d['name']
#     print('--4--')
# except Exception as e:
#     print(e)
# print('----end---')
# 4.NameError/IndexError  Exception 联合使用
# try:
#     print('--1--')
#     # name
#     print('--2--')
#     l=[1,2,3]
#     l[100]
#     print('--3--')
#     d={}
#     # d['name']
#     print('--4--')
# except NameError as e:
#     print(e)
# except IndexError as e:
#     print(e)
# except Exception as e:
#     print('统一的处理方式',e)
# print('----end---')
# 5.其他结构 try...except  else  finally #用来回收资源
# try:
#     print('--1--')
#     # name
#     print('--2--')
#     l=[1,2,3]
#     # l[100]
#     print('--3--')
#     d={}
#     # d['name']
#     print('--4--')
# except NameError as e:
#     print(e)
# except IndexError as e:
#     print(e)
# except Exception as e:
#     print('统一的处理方式',e)
# else:
#     print('没有发生异常时执行')
# finally:
#     print('无论有没有异常 都执行')
#
# print('----end---')

# try:
#     f=open('a.txt','r',encoding='utf-8')
#     print(next(f),end='')
#     print(next(f), end='')
#     print(next(f), end='')
#     print(next(f), end='')
#     print(next(f), end='')
# except Exception as e:
#     print('统一处理',e)
# finally:
#     f.close()  # 用来回收资源 表示回收的系统资源 f py会自动回收 os的资源需要f.close()
# print(f.name)
# 6.主动触发异常：raise  异常类型（值）
# class People:
#     def __init__(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
#
# p1=People('alice','12')
# print(p1.name,p1.age)
# 7.自定义异常类型 ==》 类型 = 类
# class MyException(BaseException):
#     def __init__(self,msg):
#         super().__init__()
#         self.msg=msg
#
#     def __str__(self):
#         return '<%s>'%self.msg
#
# raise MyException('自定义的异常')
# obj=MyException('自定义的异常')
# print(obj)
# 8.断言assert  下面的代码 依赖上面的代码 的结果
# info={}
# info['name']='alice'
# # info['age']=18
#
# # if 'name' not in info:
# #     raise KeyError('必须有name这个key')
# # if 'age' not in info:
# #     raise KeyError('必须有age这个key')
#
# assert ('name' in info) and ('age' in info)
#
# if info['name']=='alice' and info['age']>10:
#     print('welcome')