python之异常处理

在没有写这篇博客之前，可能在我们的程序中就抛出过很多各种各样的异常，今天笔者就做一个简单的总结。

 

打印一个不存在的变量或者名字

 

异常信息包括三部分信息：

　　1.Traceback：异常的追踪信息，异常出现在哪个文件中的哪一行

　　2.NameError：异常类型，都内置在python中

　　3.name 'x' is not defined :异常内容

 

在python中，有很多不同的异常，也就是说有很多不同的类型去标识，不同的类对象标识不同的异常，

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

 

有兴趣的朋友可以研究研究

 

什么是异常处理

　　python解释器检测到错误，触发异常（也允许程序员自己触发异常）

　　程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）

　　如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理

 

异常处理的作用

　　python解释器去执行程序，检测错误，触发异常，那么程序就会退出，后面的代码将不会执行。试想谁会去用一个经常崩溃的软件呢？所以就出现了异常处理这个机制

 

处理异常

之前我们说异常就是程序在运行中突然出现问题从而导致程序崩溃，而出现的问题我们可以进行一种判断。没错就是if语句

l=[1,2]
i=3          #索引的长度 
print (l[i])
#这样取值就会出现异常，那么我们使用if语句进行判断处理

l=[1,2]
i=3
if i < len(l):
 l[i]

#虽然实现了，但是if语句并不是进行异常处理，下面会说一种新的异常处理方法

 

 

python为每一种异常定制了一个类型，然后提供了一种特定的语法结构来进行异常处理

基本语法：

try:
 被检测的代码块
except 异常类型：
 try中一旦检测到异常，就执行这个位置的逻辑

 

l=[1,2,3,4]
try:                #检测代码块
print(l[0])
print(l[1])
print(l[2])
print(l[3])
print(l[4])
except IndexError as e:         #捕捉异常，取别名为e
print(e)
print('===>')                     #也可写其他代码逻辑

 

l=[1,2,3,4]
try:
print(l[0])
print(l[4])     #将有异常的代码放在前面，那么程序执行到这个代码后抛出异常就会执行except下面的代码
print(l[1])
print(l[2])
print(l[3])
except IndexError as e:
print(e)
print('===>')

 

 

上面的异常处理为单分支，类似于if...else... 

多分支

l=[1,2,3,4]
try:
print(l[0])
print(l[4])
print(l[1])
print(l[2])
print(l[3])
except NameError:
pass

except IndexError:
pass

except IndexError as e:
print(e)
print('===>')

#出现异常是无法预知的，如果知道抛什么异常那还需要异常处理干什么
#所以针对这种情况，该用多分支来处理

 

 

虽然上面的方法实现了，但在python中有好多异常，难道每次都要写很多分支么？为了避免这种方法，python有一个万能异常

l=[1,2,3,4]
try:
print(l[0])
print(l[4])
print(l[1])
print(l[2])
print(l[3])

except Exception:
print('========>')

 

 

多分支与万能异常使用区别：

　　Exception:检测某一个不知道的异常可以使用万能异常，然后进行处理

　　多分支：通过不同的异常，进行不同的逻辑处理

 

其他结构

s1 = 'hello'
try:
# int(s1)
print(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)

#上面三个针对不同的异常，执行不同的逻辑

except Exception as e:
print(e)
#最后这个保证我的程序不会崩溃


else:           #跟if的else没有任何关系
print('try内代码块没有异常则执行我')
finally:
print('无论异常与否,都会执行该模块,通常是进行清理工作')

 

 

 

主动触发异常

print(NameError)        #查看异常类型
raise NameError('123')  #主动触发异常

 

上面说到，异常是一个类型，那么我们就可以自定义异常

 

自定义异常

class JackError(BaseException): #继承系统基本异常
def __init__(self,msg):
 self.msg=msg

# print(JackError('Jack的异常'))
# print(str(JackError('Jack的异常')))

try:
raise JackError('Jack的异常')
except JackError as e:
print(e)

 

什么时候用异常处理

对于语法的错误，execpt是无法捕捉到的。捕捉的是语法之外的逻辑错误

try:
if asdasd
except Exception:
pass

 

 

对于异常处理，我们应该尽量的避免去使用，如果在一个程序中，每个逻辑代码都进行一个异常处理，那么我们要这个程序有什么用呢？

因为他本身就是附加在真正逻辑之外的一段代码，并且跟真正的逻辑没有任何关联，那样代码的可读性就非常差。但是总有一些情况是无法避免的。所以还是要能不用就不用吧