异常处理

1 什么是异常：

异常是错误发生的信号，一旦程序出错，并且程序没有处理这个错误，那个就会抛出异常，并且程序的运行随之终止

2 错误分为两种：
语法错误:在程序执行前就要立刻改正过来
print('xxxx'
if 1 > 2

逻辑错误

#TypeError:int类型不可迭代
for i in 3:
    pass
#ValueError
num=input(">>: ") #输入hello
int(num)

#NameError
aaa

#IndexError
l=['egon','aa']
l[3]

#KeyError
dic={'name':'egon'}
dic['age']

#AttributeError
class Foo:pass
Foo.x

#ZeroDivisionError:无法完成计算
res1=1/0
res2=1+'str'

常见的异常

AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

　　

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

异常处理

#多分支：被监测的代码块抛出的异常有多种可能性，并且我们需要针对每一种异常类型都定制专门的处理逻辑
try:
    print('===>1')
    #name
    print('===>2')
    l=[1,2,3]
    l[100]  ##
    print('===>3')
    d={}
    d['name']  ##
    print('===>4')

except NameError as e: #把异常的值赋给变量e
    print('--->',e)

except IndexError as e:
    print('--->',e)

except KeyError as e:
    print('--->',e)

print('====>afer code')  #会正常执行

#万能异常：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('====>afer code')

#打印：
===>1
===>2
异常发生啦： list index out of range
====>afer code

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)
except Exception as e:  #相当于 elif  elif  elif  最后来个else
    print('统一的处理方法')
print('====>afer code')

#打印：
===>1
===>2
===>3
---> 'name'
====>afer code

#其他结构
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)
except Exception as e:
    print('统一的处理方法')
else:   ##没有异常时执行
    print('在被检测的代码块没有发生异常时执行')
finally: ##不管有没有异常都会执行，隶属于代码块的正常逻辑  #一般在回收资源方面使用
    print('不管被检测的代码块有无发生异常都会执行')
print('====>afer code')

#打印出

===>1
===>2
===>3
---> 'name'
不管被检测的代码块有无发生异常都会执行
====>afer code

try:
    f=open('a.txt','r',encoding='utf-8')
    print(next(f))
    print(next(f))
    print(next(f))
    print(next(f))

    print(next(f))
    print(next(f))
finally:   ###不管出不出错，资源都给你回收掉了
    f.close()

#主动触发异常：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
p=People('egon',18) 

#断言assert  #断定的意思
info={}
info['name']='egon'
#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'] == 'egon' and info['age'] > 10:
    print('welcome')

#自定义异常类型 就是自定义一个类
class MyException(BaseException): #大部分还是继承别人的，自己只是改写一点
    def __init__(self,msg):
        super(MyException,self).__init__() #继承父类的__init__方法
        self.msg=msg
raise MyException('我自己的异常类型') #print(obj)  ##触发，打印出少一个异常的值，你自己给它替换了

#打印出
Traceback (most recent call last):  #追踪信息
  File "C:/Users/Administrator/PycharmProjects/myFirstpro/chapter5面向对象/异常处理.py", line 127, in <module>
    raise MyException('我自己的异常类型') #print(obj)  ##触发
__main__.MyException:  #异常类型，少一个异常值

class MyException(BaseException): #大部分还是继承别人的，自己只是改写一点
    def __init__(self,msg):
        super(MyException,self).__init__() #继承父类的__init__方法
        self.msg=msg
    def __str__(self):
        return '<%s>' %self.msg  #实现了打印的意义，自定义一个异常的格式
raise MyException('我自己的异常类型') #print(obj)  ##触发，打印出少一个异常的值，你自己给它替换了
#打印出：

Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/myFirstpro/chapter5面向对象/异常处理.py", line 127, in <module>
raise MyException('我自己的异常类型') #print(obj) ##触发，打印出少一个异常的值，你自己给它替换了
__main__.MyException: <我自己的异常类型>

不要依赖异常处理；什么时候用异常处理呢？？

一错误条件你可以预知，

二错误一定会发生，我无法预知它，导致它一定会发生，我不能让我这个程序崩溃掉