一文掌握 Python 异常处理的全部知识点

异常处理在任何一门编程语言里都是值得关注的一个话题，良好的异常处理可让你的程序更加健壮，清晰的错误信息更能帮助你快速修复问题。在Python中，和部分高级语言同样，使用了try/except/finally语句块来处理异常，若是你有其余编程语言的经验，实践起来并不难。

什么是异常？

1.错误

从软件方面来讲，错误是语法或是逻辑上的。错误是语法或是逻辑上的。

语法错误指示软件的结构上有错误，致使不能被解释器解释或编译器没法编译。这些些错误必须在程序执行前纠正。

当程序的语法正确后，剩下的就是逻辑错误了。逻辑错误多是因为不完整或是不合法的输入所致；

在其它状况下，还多是逻辑没法生成、计算、或是输出结果须要的过程没法执行。这些错误一般分别被称为域错误和范围错误。

当python检测到一个错误时，python解释器就会指出当前流已经没法继续执行下去。这时候就出现了异常。

 

2.异常

对异常的最好描述是：它是由于程序出现了错误而在正常控制流之外采起的行为。

这个行为又分为两个阶段：首先是引发异常发生的错误，而后是检测（和采起可能的措施）阶段。

第一阶段是在发生了一个异常条件（有时候也叫作例外的条件）后发生的。

只要检测到错误而且意识到异常条件，解释器就会发生一个异常。引起也能够叫作触发，抛出或者生成。解释器经过它通知当前控制流有错误发生。

python也容许程序员本身引起异常。不管是python解释器仍是程序员引起的，异常就是错误发生的信号。

当前流将被打断，用来处理这个错误并采起相应的操做。这就是第二阶段。

对于异常的处理发生在第二阶段，异常引起后，能够调用不少不一样的操做。

能够是忽略错误（记录错误但不采起任何措施，采起补救措施后终止程序。）或是减轻问题的影响后设法继续执行程序。

全部的这些操做都表明一种继续，或是控制的分支。关键是程序员在错误发生时能够指示程序如何执行。

python用异常对象(exception object)来表示异常。遇到错误后，会引起异常。

若是异常对象并未被处理或捕捉，程序就会用所谓的回溯（traceback）终止执行

异常处理

捕捉异常可使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

若是你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

如下为简单的try....except...else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #若是在try部份引起了'name'异常
except <名字>，<数据>:
<语句>        #若是引起了'name'异常，得到附加的数据
else:
<语句>        #若是没有异常发生

Try的工做原理是，当开始一个try语句后，python就在当前程序的上下文中做标记，这样当异常出现时就能够回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

1. 若是当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就经过整个try语句（除非在处理异常时又引起新的异常）。

2. 若是在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。

3. 若是在try子句执行时没有发生异常，python将执行else语句后的语句（若是有else的话），而后控制流经过整个try语句。

使用except而不带任何异常类型

你能够不带任何异常类型使用except，以下实例：

try:
   正常的操做
   ......................
except:
   发生异常则执行此处代码
   ......................
else:
   没有异常则执行此处代码

以上方式try-except语句捕获全部发生的异常。但这不是一个很好的方式，咱们不能经过该程序识别出具体的异常信息。由于它捕获全部的异常。

使用except而带多种异常类型

你也可使用相同的except语句来处理多个异常信息，以下所示：

try:
   正常的操做
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
  发生以上多个异常中的一个，执行这块代码
   ......................
else:
   若是没有异常执行这块代码

try-finally 语句

try-finally 语句不管是否发生异常都将执行最后的代码。

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

当在try块中抛出一个异常，当即执行finally块代码。

finally块中的全部语句执行后，异常被再次触发，并执行except块代码。

参数的内容不一样于异常。

下面来看一个实例：

def div(a, b):
    try:
        print(a / b)
    except ZeroDivisionError:
        print("Error: b should not be 0 !!")
    except Exception as e:
        print("Unexpected Error: {}".format(e))
    else:
        print('Run into else only when everything goes well')
    finally:
        print('Always run into finally block.')

# tests
div(2, 0)
div(2, 'bad type')
div(1, 2)

# Mutiple exception in one line
try:
    print(a / b)
except (ZeroDivisionError, TypeError) as e:
    print(e)

# Except block is optional when there is finally
try:
    open(database)
finally:
    close(database)

# catch all errors and log it
try:
    do_work()
except:    
    # get detail from logging module
    logging.exception('Exception caught!')

    # get detail from sys.exc_info() method
    error_type, error_value, trace_back = sys.exc_info()
    print(error_value)
    raise

总结以下：

1. except语句不是必须的，finally语句也不是必须的，可是两者必需要有一个，不然就没有try的意义了。

2. except语句能够有多个，Python会按except语句的顺序依次匹配你指定的异常，若是异常已经处理就不会再进入后面的except语句。

3. except语句能够以元组形式同时指定多个异常，参见实例代码。

4. except语句后面若是不指定异常类型，则默认捕获全部异常，你能够经过logging或者sys模块获取当前异常。

5. 若是要捕获异常后要重复抛出，请使用raise，后面不要带任何参数或信息。

6. 不建议捕获并抛出同一个异常，请考虑重构你的代码。

7. 不建议在不清楚逻辑的状况下捕获全部异常，有可能你隐藏了很严重的问题。

8. 尽可能使用内置的异常处理语句来 替换try/except语句，好比with语句，getattr()方法。

经验案例

传递异常 re-raise Exception
捕捉到了异常，可是又想从新引起它（传递异常），使用不带参数的raise语句便可：

def f1():
    print(1/0)
def f2():
    try:
        f1()
    except Exception as e:
        raise  # don't raise e !!!
f2()

在Python2中，为了保持异常的完整信息，那么你捕获后再次抛出时千万不能在raise后面加上异常对象，不然你的trace信息就会今后处截断。以上是最简单的从新抛出异常的作法。

还有一些技巧能够考虑，好比抛出异常前对异常的信息进行更新。

def f2():
    try:
        f1()
    except Exception as e:
        e.args += ('more info',)
        raise

Python3对重复传递异常有所改进，你能够本身尝试一下，不过建议仍是同上。

Exception 和 BaseException

当咱们要捕获一个通用异常时，应该用Exception仍是BaseException？我建议你仍是看一下 官方文档说明，这两个异常到底有啥区别呢？ 请看它们之间的继承关系。

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration...
      +-- StandardError...
      +-- Warning...

从Exception的层级结构来看，BaseException是最基础的异常类，Exception继承了它。BaseException除了包含全部的Exception外还包含了SystemExit，KeyboardInterrupt和GeneratorExit三个异常。

有此看来你的程序在捕获全部异常时更应该使用Exception而不是BaseException，由于另外三个异常属于更高级别的异常，合理的作法应该是交给Python的解释器处理。

except Exception as e和 except Exception, e

代码示例以下：

try:
    do_something()
except NameError as e:  # should
    pass
except KeyError, e:  # should not
    pass

在Python2的时代，你可使用以上两种写法中的任意一种。在Python3中你只能使用第一种写法，第二种写法被废弃掉了。第一个种写法可读性更好，并且为了程序的兼容性和后期移植的成本，请你也抛弃第二种写法。

raise “Exception string”

把字符串当成异常抛出看上去是一个很是简洁的办法，但实际上是一个很是很差的习惯。

if is_work_done():
    pass
else:
    raise "Work is not done!" # not cool

上面的语句若是抛出异常，那么会是这样的：

Traceback (most recent call last):
  File "/demo/exception_hanlding.py", line 48, in <module>
    raise "Work is not done!"
TypeError: exceptions must be old-style classes or derived from BaseException, not str

这在Python2.4之前是能够接受的作法，可是没有指定异常类型有可能会让下游没办法正确捕获并处理这个异常，从而致使你的程序挂掉。简单说，这种写法是是封建时代的陋习，应该扔了。

使用内置的语法范式代替try/except

Python 自己提供了不少的语法范式简化了异常的处理，好比for语句就处理的StopIteration异常，让你很流畅地写出一个循环。

with语句在打开文件后会自动调用finally中的关闭文件操做。咱们在写Python代码时应该尽可能避免在遇到这种状况时还使用try/except/finally的思惟来处理。

# should not
try:
    f = open(a_file)
    do_something(f)
finally:
    f.close()
# should 
with open(a_file) as f:
    do_something(f)

再好比，当咱们须要访问一个不肯定的属性时，有可能你会写出这样的代码：

try:
    test = Test()
    name = test.name  # not sure if we can get its name
except AttributeError:
    name = 'default'

其实你可使用更简单的getattr()来达到你的目的。

最佳实践

最佳实践不限于编程语言，只是一些规则和填坑后的收获。

1.只处理你知道的异常捕获所异常而后吞掉它们。

2.抛出的异常应该说明缘由，有时候你知道异常类型也猜不出因此然的。

3.避免在catch语句块中干一些没意义的事情。

4.不要使用异常来控制流程，那样你的程序会无比难懂和难维护。

5.若是有须要，切记使用finally来释放资源。

6若是有须要，请不要忘记在处理异常后作清理工做或者回滚操做。

异常速查表